lib/epson-net-snmp.c

   1 /*________________________________   epson-net-snmp.c   ________________________________*/\r
   2 \r
   3 /*       1         2         3         4         5         6         7         8        */\r
   4 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
   5 /*******************************************|********************************************/\r
   6 /*\r
   7  *   Copyright (c) 2009  Seiko Epson Corporation                 All rights reserved.\r
   8  *\r
   9  *   Copyright protection claimed includes all forms and matters of\r
  10  *   copyrightable material and information now allowed by statutory or judicial\r
  11  *   law or hereinafter granted, including without limitation, material generated\r
  12  *   from the software programs which are displayed on the screen such as icons,\r
  13  *   screen display looks, etc.\r
  14  *\r
  15  */\r
  16 /*******************************************|********************************************/\r
  17 /*                                                                                      */\r
  18 /*                                SNMP protocol Module                                  */\r
  19 /*                                                                                      */\r
  20 /*                                Public Function Calls                                 */\r
  21 /*                              --------------------------                              */\r
  22 /*      EPS_ERR_CODE snmpFindStart          (sock                               );      */\r
  23 /*              EPS_ERR_CODE snmpFind               (sock, printer                      );      */\r
  24 /*      EPS_ERR_CODE snmpFindEnd                (sock                               );      */\r
  25 /*      EPS_ERR_CODE snmpProbeByID          (printerUUID, timeout, printer      );      */\r
  26 /*      EPS_ERR_CODE snmpGetStatus          (sock, address, pstInfo             );      */\r
  27 /*      EPS_ERR_CODE snmpGetPMString        (printer, pString, bufSize          );      */\r
  28 /*      EPS_ERR_CODE snmpMechCommand        (printer, Command                   );      */\r
  29 /*      EPS_ERR_CODE snmpOpenSocket                     (sock                               );      */\r
  30 /*              EPS_ERR_CODE snmpCloseSocket            (sock                               );      */\r
  31 /*              EPS_ERR_CODE mibGetPhysAddress          (address, val, vallen                           );              */\r
  32 /*              EPS_ERR_CODE mibConfirmPrintPort        (address, printPort                                     );              */\r
  33 /*                                                                                      */\r
  34 /*******************************************|********************************************/\r
  35 \r
  36 /*------------------------------------  Includes   -------------------------------------*/\r
  37 /*******************************************|********************************************/\r
  38 #include "epson-escpr-def.h"\r
  39 #include "epson-escpr-err.h"\r
  40 #include "epson-escpr-mem.h"\r
  41 #include "epson-escpr-services.h"\r
  42 #include "epson-protocol.h"\r
  43 #include "epson-net-snmp.h"\r
  44 #ifdef GCOMSW_CMD_ESCPAGE\r
  45         #include "epson-escpr-media.h"\r
  46 \r
  47         #ifdef GCOMSW_CMD_ESCPAGE_S\r
  48         #include "epson-escpage-s.h"\r
  49         #endif\r
  50 #endif\r
  51 \r
  52 /*-----------------------------------  Definitions  ------------------------------------*/\r
  53 /*******************************************|********************************************/\r
  54 #ifdef EPS_LOG_MODULE_LPR\r
  55 #define EPS_LOG_MODULE  EPS_LOG_MODULE_LPR\r
  56 #else\r
  57 #define EPS_LOG_MODULE  0\r
  58 #endif\r
  59 \r
  60 #define SNMP_PORT_NUM                   (161)                           /* Protocol port number                         */\r
  61 #define SNMP_MAX_BUF                    (512)                           /* Communication buffer size            */\r
  62 #define SNMP_MAX_OID                    (128)                           /* max oid size                         */\r
  63 \r
  64 /* SNMP variables                                                                       */\r
  65 #define ASN_VT_INTEGER                  (0x02)                          /* integer                          */\r
  66 #define ASN_VT_OCTET_STRING             (0x04)                          /* octet stream                     */\r
  67 #define ASN_VT_NULL                             (0x05)                          /* null                             */\r
  68 #define ASN_VT_OBJECT_ID                (0x06)                          /* OID                              */\r
  69 #define ASN_VT_SEQUENCE                 (0x30)                          /* sequence                         */\r
  70 \r
  71 /* SNMP message                                                                         */\r
  72 #define ASN_PDU_GET                             (EPS_UINT8)(0xA0)   /* GetRequest                       */\r
  73 #define ASN_PDU_GET_NEXT                (EPS_UINT8)(0xA1)   /* GetNextRequest                   */\r
  74 #define ASN_PDU_RESP                    (EPS_UINT8)(0xA2)   /* Response                         */\r
  75 #define ASN_PDU_SET                             (EPS_UINT8)(0xA3)   /* SetRequest                       */\r
  76 #define ASN_PDU_TRAP                    (EPS_UINT8)(0xA4)   /* Trap                             */\r
  77 #define ASN_PDU_TRAP_RSP                (EPS_UINT8)(0xC2)   /* TrapResponse                     */\r
  78 \r
  79 \r
  80 #define SNMP_VERSION                    (0)\r
  81 #define SNMP_COMMUNITY_STR              "public"\r
  82 /* Response corde */\r
  83 #define SNMP_ERR_NONE                   (0)                                     /* noError(0)                                           */\r
  84 #define SNMP_ERR_TOO_BIG                (1)                                     /* tooBig(1)                                            */\r
  85 #define SNMP_ERR_SUCH_NAME              (2)                                     /* noSuchName(2)                                        */\r
  86 #define SNMP_ERR_BAD_VALUE              (3)                                     /* badValue(3)                                          */\r
  87 #define SNMP_ERR_READ_ONLY              (4)                                     /* readOnly(4)                                          */\r
  88 #define SNMP_ERR_GENERAL                (5)                                     /* genErr(5)                                            */\r
  89 \r
  90 #define SNMP_OBJID_LEN                  (129)\r
  91 \r
  92 /* MIB status */\r
  93         /* hrDeviceStatus */\r
  94 #define MIB_DEVST_RUNNING               (2)\r
  95 #define MIB_DEVST_WARNING               (3)\r
  96 #define MIB_DEVST_DOWN                  (5)\r
  97         /* hrPrinterStatus */\r
  98 #define MIB_PRNST_OTHER                 (1)\r
  99 #define MIB_PRNST_IDLE                  (3)\r
 100 #define MIB_PRNST_PRINTING              (4)\r
 101 #define MIB_PRNST_WARMUP                (5)\r
 102         /* hrPrinterDetectedErrorState */\r
 103 #define MIB_PRERR_NOPAPER               (1 << 6)\r
 104 #define MIB_PRERR_NOINK                 (1 << 4)\r
 105 #define MIB_PRERR_COVEROPEN             (1 << 3)\r
 106 #define MIB_PRERR_PAPERJAM              (1 << 2)\r
 107 \r
 108 /*---------------------------  Data Structure Declarations   ---------------------------*/\r
 109 /*******************************************|********************************************/\r
 110 /* SNMP variant type */\r
 111 typedef struct tag_ASN_VARIANT {       \r
 112         EPS_INT8        type;\r
 113         EPS_UINT32      length;\r
 114         union{\r
 115                 EPS_INT32       v_long;            /* Integer                                       */\r
 116                 EPS_INT8*       v_str;             /* OCTET_STRING, ASN_VT_OBJECT_ID                */\r
 117         } val;                          \r
 118 }ASN_VARIANT;\r
 119 \r
 120 /* If type is OBJECT_ID, ParseField() alloc heap.                                                                       */\r
 121 #define EPS_REREASE_VARIANT( v )                                \\r
 122         {                                                                                       \\r
 123                 if( ASN_VT_OBJECT_ID == (v).type ){             \\r
 124                         EPS_SAFE_RELEASE( (v).val.v_str );      \\r
 125                 }                                                                               \\r
 126                 (v).type = ASN_VT_NULL;                                 \\r
 127         }\r
 128 \r
 129 \r
 130 /*----------------------------  ESC/P-R Lib Global Variables  --------------------------*/\r
 131 /*******************************************|********************************************/\r
 132 \r
 133         /*** Extern Function                                                                */\r
 134 extern EPS_NET_FUNC             epsNetFnc;\r
 135 extern EPS_CMN_FUNC             epsCmnFnc;\r
 136 \r
 137         /*** Find                                                                           */\r
 138 extern EPS_BOOL                 g_FindBreak;                    /* Find printer end flag                */\r
 139 \r
 140         /* CPU Endian-ness                                                                  */\r
 141 extern EPS_INT16                cpuEndian;\r
 142 \r
 143 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 144      interfaces(2) ifTable(2) ifEntry(1) 6 } */\r
 145 static EPS_INT8 s_oidPhysAddress[]  = "1.3.6.1.2.1.2.2.1.6";\r
 146 \r
 147 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 148          tcp(6) tcpConnTable(13) tcpConnEntry(1) 3 } */\r
 149 static EPS_INT8 s_oidTcpConnLocalPort[]= "1.3.6.1.2.1.6.13.1.3";\r
 150 \r
 151 \r
 152 #ifdef GCOMSW_CMD_ESCPAGE\r
 153 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 154       host(25) hrDevice(3) hrDeviceTable(2) hrDeviceEntry(1) hrDeviceStatus(5) } */\r
 155 static EPS_INT8 s_oidDevStatus[]        = "1.3.6.1.2.1.25.3.2.1.5";\r
 156 \r
 157 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 158      host(25) hrDevice(3) hrPrinterTable(5) hrPrinterEntry(1) hrPrinterStatus(1) } */\r
 159 static EPS_INT8 s_oidPrinterStatus[]= "1.3.6.1.2.1.25.3.5.1.1";\r
 160 \r
 161 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 162      host(25) hrDevice(3) hrPrinterTable(5) hrPrinterEntry(1) hrPrinterDetectedErrorState(2) } */\r
 163 static EPS_INT8 s_oidPrinterError[] = "1.3.6.1.2.1.25.3.5.1.2";\r
 164 \r
 165 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) printmib(43) prtMarkerColorant(12)\r
 166       prtMarkerColorantTable(1) prtMarkerColorantEntry(1) 4 } */\r
 167 static EPS_INT8 s_oidMarkerColorant[] = "1.3.6.1.2.1.43.12.1.1.4";\r
 168 \r
 169 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 170      printmib(43) prtMarkerSupplies(11) prtMarkerSuppliesTable(1) prtMarkerSuppliesEntry(1)\r
 171          prtMarkerSuppliesLevel(9) } */\r
 172 static EPS_INT8 s_oidMarkerLevel[]      = "1.3.6.1.2.1.43.11.1.1.9";\r
 173 \r
 174 /* { iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) \r
 175      printmib(43) prtInput(8) prtInputTable(2) prtInputEntry(1) prtInputName(13) } */\r
 176 static EPS_INT8 s_oidInputName[]        = "1.3.6.1.2.1.43.8.2.1.13";\r
 177 #endif\r
 178 \r
 179 static EPS_INT8 s_oidPrvPrinter[]               = "1.3.6.1.4.1.1248.1.2.2.1.1.1.1";\r
 180 static EPS_INT8 s_oidPrvBonjourName[]   = "1.3.6.1.4.1.1248.1.1.3.1.14.4.1.2";\r
 181 static EPS_INT8 s_oidPrvStatus[]                = "1.3.6.1.4.1.1248.1.2.2.1.1.1.4";\r
 182 static EPS_INT8 s_oidPrvCtrl[]                  = "1.3.6.1.4.1.1248.1.2.2.44.1.1.2";\r
 183 \r
 184 static EPS_INT8 g_TrnBuff[SNMP_MAX_BUF];\r
 185 \r
 186 \r
 187 /*--------------------------  Public Functions Declaration   ---------------------------*/\r
 188 /*******************************************|********************************************/\r
 189 static EPS_ERR_CODE snmpGetStatus       (EPS_SOCKET, const EPS_INT8*, EPS_STATUS_INFO*      );\r
 190 static EPS_ERR_CODE snmpGetInkInfo      (const EPS_INT8*, EPS_STATUS_INFO*                  );\r
 191 static EPS_ERR_CODE snmpGetPMString (const EPS_PRINTER_INN*, EPS_INT32, \r
 192                                                                          EPS_UINT8*, EPS_INT32*                             );\r
 193 static EPS_ERR_CODE snmpMechCommand (const EPS_PRINTER_INN*, EPS_INT32                  );\r
 194 #ifdef GCOMSW_CMD_ESCPAGE\r
 195 static EPS_ERR_CODE snmpGetStatus_Page(EPS_SOCKET, const EPS_INT8*, EPS_STATUS_INFO*    );\r
 196 static EPS_ERR_CODE snmpGetInkInfo_Page(const EPS_INT8*, EPS_STATUS_INFO*               );\r
 197 static EPS_ERR_CODE snmpGetPMString_Page(const EPS_PRINTER_INN*, EPS_INT32, \r
 198                                                                          EPS_UINT8*, EPS_INT32*                             );\r
 199 static EPS_ERR_CODE snmpMechCommand_Page(const EPS_PRINTER_INN*, EPS_INT32              );\r
 200 #endif\r
 201 \r
 202 /*--------------------------  Local Functions Declaration   ----------------------------*/\r
 203 /*******************************************|********************************************/\r
 204 static EPS_ERR_CODE SnmpTransact    (const EPS_INT8*, EPS_INT32, const EPS_INT8*, \r
 205                                                                          EPS_UINT8, ASN_VARIANT* pdu                        );\r
 206 static EPS_ERR_CODE SnmpTransactS   (EPS_SOCKET, const EPS_INT8*, EPS_INT32, \r
 207                                                                          const EPS_INT8*, EPS_UINT8, ASN_VARIANT*           );\r
 208 \r
 209 static EPS_ERR_CODE SnmpFindRecv    (EPS_SOCKET, EPS_UINT16, EPS_INT32, \r
 210                                                                          const EPS_INT8*, const EPS_INT8*, EPS_PRINTER_INN**);\r
 211 \r
 212 static EPS_ERR_CODE mibGetPhysAddress(const EPS_INT8*, EPS_INT8*, EPS_UINT32            );\r
 213 static EPS_ERR_CODE mibConfirmPrintPort(const EPS_INT8*, EPS_UINT16                                             );\r
 214 #ifdef GCOMSW_CMD_ESCPAGE_S\r
 215 static EPS_ERR_CODE mibGetMaxMediaXFeedDir(const EPS_INT8* address, EPS_UINT32* val             );\r
 216 #endif\r
 217 static EPS_ERR_CODE GetPDU          (EPS_INT8*, EPS_INT32, EPS_UINT8, const EPS_INT8*, \r
 218                                                                          ASN_VARIANT*, EPS_INT8*, EPS_INT32                 );\r
 219 \r
 220 #ifdef GCOMSW_CMD_ESCPAGE\r
 221 static EPS_INT32 GetColorID         (EPS_INT8*                                          );\r
 222 #endif\r
 223 static EPS_ERR_CODE SnmpWalkMib     (EPS_SOCKET, const EPS_INT8*, const EPS_INT8*, ASN_VARIANT*);\r
 224 static EPS_UINT8    GetRequestId    (void                                               );\r
 225 static EPS_ERR_CODE ParseLength     (EPS_INT8**, EPS_INT32*, EPS_UINT32*                );\r
 226 static EPS_ERR_CODE ParseField      (EPS_INT8**, EPS_INT32*, ASN_VARIANT*               );\r
 227 \r
 228 static EPS_ERR_CODE CreateCommand   (EPS_INT8*, EPS_UINT8, EPS_UINT8, const EPS_INT8*, EPS_INT32*);\r
 229 static EPS_INT8*    MakeLength      (EPS_INT32, EPS_INT8*                               );\r
 230 static EPS_INT8*    MakeIntField    (EPS_INT32, EPS_INT8*                               );\r
 231 static EPS_INT8*    MakeStrField    (const EPS_INT8*, EPS_INT8*                         );\r
 232 static EPS_ERR_CODE MakeOidField    (const EPS_INT8*, EPS_INT8**                        );\r
 233 static EPS_ERR_CODE MakeSequens     (EPS_INT8*, EPS_UINT32*, EPS_BOOL                   );\r
 234 \r
 235 static EPS_UINT16   IntToBer        (EPS_INT32, EPS_INT8*                               );\r
 236 static EPS_INT32    BerToInt        (EPS_INT8*, EPS_INT32                               );\r
 237 static EPS_ERR_CODE StrToOid        (const EPS_INT8*, EPS_INT8*, EPS_UINT16*            );\r
 238 static EPS_ERR_CODE OidToStr        (EPS_INT8*, EPS_UINT32, EPS_INT8**                  );\r
 239 \r
 240 \r
 241 \r
 242 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 243 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 244 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 245 /*--------------------              Public Functions               ---------------------*/\r
 246 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
 247 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 248 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
 249 \r
 250 /*******************************************|********************************************/\r
 251 /*                                                                                      */\r
 252 /* Function name:   snmpSetupSTFunctions()                                              */\r
 253 /*                                                                                      */\r
 254 /* Arguments                                                                            */\r
 255 /* ---------                                                                            */\r
 256 /* Name:        Type:               Description:                                        */\r
 257 /* N/A                                                                                  */\r
 258 /*                                                                                      */\r
 259 /* Return value:                                                                        */\r
 260 /*      EPS_ERR_NONE                            - Success (Opened Communication)                    */\r
 261 /*                                                                                      */\r
 262 /* Description:                                                                         */\r
 263 /*     Initialize protocol layer.                                                       */\r
 264 /*                                                                                      */\r
 265 /*******************************************|********************************************/\r
 266 void    snmpSetupSTFunctions (\r
 267                                                                 \r
 268                         EPS_SNMP_FUNCS*                 fnc,\r
 269                         const EPS_PRINTER_INN*  printer\r
 270                  \r
 271 ){\r
 272         EPS_LOG_FUNCIN\r
 273 \r
 274 #ifdef GCOMSW_CMD_ESCPAGE\r
 275         if( EPS_LANG_ESCPR != printer->language ){\r
 276                 fnc->GetStatus          = snmpGetStatus_Page;\r
 277                 fnc->GetInkInfo         = snmpGetInkInfo_Page;\r
 278                 fnc->GetPMString    = snmpGetPMString_Page;\r
 279                 fnc->MechCommand    = snmpMechCommand_Page;\r
 280         } \r
 281         else\r
 282 #endif\r
 283         {\r
 284                 fnc->GetStatus          = snmpGetStatus;\r
 285                 fnc->GetInkInfo         = snmpGetInkInfo;\r
 286                 fnc->GetPMString    = snmpGetPMString;\r
 287                 fnc->MechCommand    = snmpMechCommand;\r
 288         }\r
 289 \r
 290         EPS_RETURN_VOID\r
 291 }\r
 292 \r
 293 /*******************************************|********************************************/\r
 294 /*                                                                                      */\r
 295 /* Function name:     snmpOpenSocket()                                                  */\r
 296 /*                                                                                      */\r
 297 /* Arguments                                                                            */\r
 298 /* ---------                                                                            */\r
 299 /* Name:        Type:               Description:                                        */\r
 300 /* sock         EPS_SOCKET*         O: SNMP socket                                      */\r
 301 /*                                                                                      */\r
 302 /* Return value:                                                                        */\r
 303 /*      EPS_ERR_CODE    : result code                                                   */\r
 304 /*                                                                                      */\r
 305 /* Description:                                                                         */\r
 306 /*      Create SNMP socket for any command.                                             */\r
 307 /*                                                                                      */\r
 308 /*******************************************|********************************************/\r
 309 EPS_ERR_CODE snmpOpenSocket(\r
 310                                                         \r
 311                 EPS_SOCKET* sock\r
 312                 \r
 313 ){\r
 314         *sock = epsNetFnc.socket( EPS_PF_INET, EPS_SOCK_DGRAM, EPS_PROTOCOL_UDP );\r
 315         if( EPS_INVALID_SOCKET == *sock ){\r
 316                 return EPS_ERR_COMM_ERROR;\r
 317         }\r
 318 \r
 319         return EPS_ERR_NONE;\r
 320 }\r
 321 \r
 322 \r
 323 /*******************************************|********************************************/\r
 324 /*                                                                                      */\r
 325 /* Function name:     snmpCloseSocket()                                                 */\r
 326 /*                                                                                      */\r
 327 /* Arguments                                                                            */\r
 328 /* ---------                                                                            */\r
 329 /* Name:        Type:               Description:                                        */\r
 330 /* sock         EPS_SOCKET*         I/O: SNMP socket                                    */\r
 331 /*                                                                                      */\r
 332 /* Return value:                                                                        */\r
 333 /*      (none)                                                                          */\r
 334 /*                                                                                      */\r
 335 /* Description:                                                                         */\r
 336 /*      Destory SNMP socket.                                                            */\r
 337 /*                                                                                      */\r
 338 /*******************************************|********************************************/\r
 339 void snmpCloseSocket(\r
 340                                          \r
 341                 EPS_SOCKET* sock\r
 342                 \r
 343 ){\r
 344         if(EPS_INVALID_SOCKET != *sock){\r
 345                 epsNetFnc.close( *sock );\r
 346                 *sock = EPS_INVALID_SOCKET;\r
 347         }\r
 348 }\r
 349 \r
 350 \r
 351 \r
 352 /*******************************************|********************************************/\r
 353 /*                                                                                      */\r
 354 /* Function name:     snmpFindStart()                                                       */\r
 355 /*                                                                                      */\r
 356 /* Arguments                                                                            */\r
 357 /* ---------                                                                            */\r
 358 /* Name:        Type:               Description:                                        */\r
 359 /* sock             EPS_SOCKET          O: Discover send/recv Socket                        */\r
 360 /* address      EPS_INT8*           I: Destination IP Address string (NULL terminate)   */\r
 361 /* multi        EPS_BOOL            I: If TRUE, send multicast                          */\r
 362 /*                                                                                      */\r
 363 /* Return value:                                                                        */\r
 364 /*      EPS_ERR_NONE                    - Success                                       */\r
 365 /*      EPS_ERR_COMM_ERROR                                                                                              */\r
 366 /*                                                                                      */\r
 367 /* Description:                                                                         */\r
 368 /*      Open socekt & Send discover messasge.                                           */\r
 369 /*                                                                                      */\r
 370 /*******************************************|********************************************/\r
 371 EPS_ERR_CODE snmpFindStart (\r
 372 \r
 373                 EPS_SOCKET*             sock,\r
 374                 const EPS_INT8* address,\r
 375                 EPS_BOOL        multi\r
 376 \r
 377 ){\r
 378         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 379         EPS_UINT8       nRqID = 0;\r
 380         EPS_INT32       nSize = 0;\r
 381         ASN_VARIANT pdu;\r
 382 \r
 383         EPS_INT32 i = 0;                                        /* Temporary counter for number of discoveries  */\r
 384 \r
 385         EPS_LOG_FUNCIN\r
 386 \r
 387         /* Create UDP broadcast socket                                                                                                          */\r
 388         if(EPS_INVALID_SOCKET == *sock){        /* First Time */\r
 389                 *sock = epsNetFnc.socket( EPS_PF_INET, EPS_SOCK_DGRAM, EPS_PROTOCOL_UDP );\r
 390                 if( EPS_INVALID_SOCKET == *sock ){\r
 391                         EPS_RETURN( EPS_ERR_COMM_ERROR )\r
 392                 }\r
 393 \r
 394                 if(multi){\r
 395                         if( EPS_SOCKET_SUCCESS != epsNetFnc.setBroadcast(*sock) ){\r
 396                                 /* If error occurr, close socket                                                                                        */\r
 397                                 epsNetFnc.close( *sock );\r
 398                                 *sock = EPS_INVALID_SOCKET;\r
 399                                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
 400                         }\r
 401                 }\r
 402         }\r
 403 \r
 404         /* Create  command                                                                                                                              */\r
 405         memset(&pdu, 0, sizeof(pdu));\r
 406         nRqID = GetRequestId();\r
 407         if( EPS_ERR_NONE != (ret = CreateCommand(g_TrnBuff, ASN_PDU_GET_NEXT, nRqID,\r
 408                                                                                 s_oidPrvPrinter, &nSize)) ){\r
 409                 EPS_RETURN( ret )\r
 410         }\r
 411 \r
 412         /* Send                                                                                                                                                         */\r
 413         for (i = 0; i < EPSNET_NUM_DISCOVERIES; i++) {\r
 414                 if ( 0 >= epsNetFnc.sendTo(*sock, (char*)g_TrnBuff, nSize,  \r
 415                                                                            address, SNMP_PORT_NUM, 0)){\r
 416                                 /* If error occurr, close socket                                                                                        */\r
 417                         epsNetFnc.close( *sock );\r
 418                         *sock = EPS_INVALID_SOCKET;\r
 419                         EPS_RETURN( EPS_ERR_COMM_ERROR )\r
 420                 }\r
 421         }\r
 422         \r
 423         EPS_RETURN( ret )\r
 424 }\r
 425 \r
 426 \r
 427 /*******************************************|********************************************/\r
 428 /*                                                                                      */\r
 429 /* Function name:     snmpFind()                                                            */\r
 430 /*                                                                                      */\r
 431 /* Arguments                                                                            */\r
 432 /* ---------                                                                            */\r
 433 /* Name:        Type:               Description:                                        */\r
 434 /* sock             EPS_SOCKET          I: Discover Socket                                              */\r
 435 /* printer              EPS_PRINTER_INN**   O: pointer for found printer structure              */\r
 436 /*                                                                                      */\r
 437 /* Return value:                                                                        */\r
 438 /*      EPS_ERR_NONE                    - Success                                       */\r
 439 /*      EPS_ERR_COMM_ERROR              - socket error                                      */\r
 440 /*      EPS_ERR_MEMORY_ALLOCATION                                                                                   */\r
 441 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
 442 /*      EPS_ERR_PRINTER_NOT_USEFUL      - received but not usefl                        */\r
 443 /*                                                                                      */\r
 444 /* Description:                                                                         */\r
 445 /*      Receive discover messasge. Get printer name.                                    */\r
 446 /*                                                                                      */\r
 447 /*******************************************|********************************************/\r
 448 EPS_ERR_CODE snmpFind(\r
 449 \r
 450                 EPS_SOCKET                      sock,\r
 451                 EPS_UINT16                      printPort,\r
 452                 EPS_INT32                       printProtocol,\r
 453                 EPS_PRINTER_INN**   printer\r
 454                 \r
 455 ){\r
 456         EPS_LOG_FUNCIN\r
 457 \r
 458         EPS_RETURN( SnmpFindRecv(sock, printPort, printProtocol, NULL, NULL, printer) )\r
 459 }\r
 460 \r
 461 \r
 462 \r
 463 /*******************************************|********************************************/\r
 464 /*                                                                                      */\r
 465 /* Function name:     snmpFindEnd()                                                                 */\r
 466 /*                                                                                      */\r
 467 /* Arguments                                                                            */\r
 468 /* ---------                                                                            */\r
 469 /* Name:        Type:               Description:                                        */\r
 470 /* sock             EPS_SOCKET          I: Discover Socket                                              */\r
 471 /*                                                                                      */\r
 472 /* Return value:                                                                        */\r
 473 /*      EPS_ERR_NONE                - Success                                           */\r
 474 /*      EPS_ERR_COMM_ERROR          - Close socket failed                                       */\r
 475 /*                                                                                      */\r
 476 /* Description:                                                                         */\r
 477 /*      close discover process.                                                                             */\r
 478 /*                                                                                      */\r
 479 /*******************************************|********************************************/\r
 480 EPS_ERR_CODE snmpFindEnd(\r
 481                                                  \r
 482          EPS_SOCKET sock\r
 483                  \r
 484 ){\r
 485         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 486         EPS_INT8  *pRecvBuf = NULL;                                                     /* Receive Buffer                               */\r
 487 \r
 488 EPS_LOG_FUNCIN\r
 489         if(EPS_INVALID_SOCKET == sock){\r
 490                 EPS_RETURN( EPS_ERR_NONE )\r
 491         }\r
 492 \r
 493         pRecvBuf = (EPS_INT8*)EPS_ALLOC( SNMP_MAX_BUF );\r
 494         if( NULL == pRecvBuf ){\r
 495                 ret = EPS_ERR_MEMORY_ALLOCATION;\r
 496                 goto snmpFindEnd_END;\r
 497         }\r
 498 \r
 499         /* Read All resopnse */\r
 500         while(0 < epsNetFnc.receive(sock, pRecvBuf, SNMP_MAX_BUF, EPSNET_FIND_RECV_TIMEOUT) );\r
 501 \r
 502 snmpFindEnd_END:\r
 503         EPS_SAFE_RELEASE( pRecvBuf );\r
 504 \r
 505         epsNetFnc.shutdown(sock, EPS_SHUTDOWN_SEND);\r
 506         epsNetFnc.shutdown(sock, EPS_SHUTDOWN_RECV);\r
 507         epsNetFnc.shutdown(sock, EPS_SHUTDOWN_BOTH);\r
 508 \r
 509         /* Close UDP socket                                                                                                                                     */\r
 510         if (EPS_SOCKET_SUCCESS != epsNetFnc.close(sock) ){\r
 511                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
 512         }\r
 513 \r
 514         EPS_RETURN( ret )\r
 515 }\r
 516 \r
 517 \r
 518 /*******************************************|********************************************/\r
 519 /*                                                                                      */\r
 520 /* Function name:   snmpProbeByID()                                                     */\r
 521 /*                                                                                      */\r
 522 /* Arguments                                                                            */\r
 523 /* ---------                                                                            */\r
 524 /* Name:        Type:               Description:                                        */\r
 525 /* printerUUID  EPS_INT8*               I: printr ID String                                 */\r
 526 /* timeout      EPS_UINT32          I: find timeout                                     */\r
 527 /* printer          EPS_PRINTER*                O: Pointer for Alloc Printer infomation structure   */\r
 528 /*                                                                                      */\r
 529 /* Return value:                                                                        */\r
 530 /*      EPS_ERR_NONE                - Success                                           */\r
 531 /*      EPS_ERR_COMM_ERROR              - socket failed                                         */\r
 532 /*      EPS_ERR_MEMORY_ALLOCATION   - Failed to allocate memory                         */\r
 533 /*      EPS_ERR_PRINTER_NOT_FOUND   - printer not found                                 */\r
 534 /*                                                                                      */\r
 535 /* Description:                                                                         */\r
 536 /*     Probe printer by ID String.                                                                      */\r
 537 /*                                                                                      */\r
 538 /*******************************************|********************************************/\r
 539 EPS_ERR_CODE   snmpProbeByID (\r
 540 \r
 541                 EPS_INT8*                       printerUUID,\r
 542                 EPS_UINT16                      printPort,\r
 543                 EPS_INT32                       printProtocol,\r
 544                 EPS_UINT32                      timeout, \r
 545                 EPS_PRINTER_INN**       printer\r
 546 \r
 547 ){\r
 548 /*** Declare Variable Local to Routine                                                  */\r
 549     EPS_ERR_CODE    ret = EPS_ERR_NONE;                         /* Return status of internal calls  */\r
 550         EPS_SOCKET          sock = EPS_INVALID_SOCKET;\r
 551         EPS_UINT32          tmStart, tmNow, tmSpan, tmReq;\r
 552         EPS_INT8                compName[EPS_NAME_BUFFSIZE];\r
 553         EPS_INT8                compSysName[EPS_NAME_BUFFSIZE];\r
 554     EPS_INT8*           pPos = NULL;\r
 555     EPS_INT32           nSegCnt = 0;\r
 556 \r
 557 EPS_LOG_FUNCIN\r
 558 \r
 559 /*** Initialize Local & global Variables                                                */\r
 560         if(epsCmnFnc.getTime){\r
 561                 tmStart = tmReq = epsCmnFnc.getTime();\r
 562         } else{\r
 563                 timeout = tmStart = tmNow = tmReq = 0;\r
 564         }\r
 565 \r
 566 /*** Parse definition String                                                            */\r
 567         pPos = strtok(printerUUID, EPS_NETID_SEP);\r
 568     for(nSegCnt = 0; pPos != NULL && nSegCnt < EPS_NETID_SEGNUM; nSegCnt++){\r
 569                 switch(nSegCnt){\r
 570                 case 0:                 /* Get model name */\r
 571                         strcpy(compName, pPos);\r
 572                         break;\r
 573                 case 1:                 /* Get SysName */\r
 574                         strcpy(compSysName, pPos);\r
 575                         break;\r
 576                 }\r
 577 \r
 578                 pPos = strtok(NULL, EPS_NETID_SEP);\r
 579     }\r
 580         if(nSegCnt < EPS_NETID_SEGNUM){\r
 581                 EPS_RETURN( EPS_ERR_INV_ARG_PRINTER_ID )\r
 582         }\r
 583 \r
 584 /*** probe message broadcast                                                            */\r
 585         ret = snmpFindStart( &sock, EPSNET_UDP_BROADCAST_ADDR, TRUE );\r
 586         if(EPS_ERR_NONE != ret){\r
 587                 goto snmpProbeByID_END;\r
 588         }\r
 589 \r
 590 /*** Check response                                                                     */\r
 591         ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 592         while( EPS_ERR_PRINTER_NOT_FOUND == ret ||\r
 593                    EPS_ERR_PRINTER_NOT_USEFUL== ret )\r
 594         {\r
 595                 ret = SnmpFindRecv(sock, printPort, printProtocol, compSysName, compName, printer);\r
 596 \r
 597                 /* epsCancelFindPriter() */\r
 598                 if( epsCmnFnc.lockSync && epsCmnFnc.unlockSync ){\r
 599                         if( 0 == epsCmnFnc.lockSync() ){\r
 600                                 if( g_FindBreak ){\r
 601                                         epsCmnFnc.unlockSync();\r
 602                                         break;\r
 603                                 }\r
 604                                 epsCmnFnc.unlockSync();\r
 605                         }\r
 606                 }\r
 607 \r
 608                 /* Timeout */\r
 609                 if(timeout > 0){\r
 610                         tmNow = epsCmnFnc.getTime();\r
 611                         tmSpan = (EPS_UINT32)(tmNow - tmStart);\r
 612                         /*EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )*/\r
 613                         if( tmSpan >= timeout ){\r
 614                                 break;\r
 615                         }\r
 616                 }\r
 617 \r
 618                 /*EPS_DBGPRINT( ("TM %u - %u <> %u\n", tmNow, tmStart, tmSpan) )*/\r
 619                 if( EPS_COM_NOT_RECEIVE == ret ){\r
 620                         /* beef up */\r
 621                         if( EPSNET_FIND_REREQUEST_TIME <= (EPS_UINT32)(tmNow - tmReq) ){\r
 622                                 /*EPS_DBGPRINT( ("beef up\n") )*/\r
 623                                 ret = snmpFindStart( &sock, EPSNET_UDP_BROADCAST_ADDR, TRUE );\r
 624                                 if(EPS_ERR_NONE != ret){\r
 625                                         goto snmpProbeByID_END;\r
 626                                 }\r
 627                         }\r
 628 \r
 629                         ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 630                 } else{\r
 631                         tmReq = tmNow;\r
 632                 }\r
 633         }\r
 634 \r
 635         if( EPS_ERR_PRINTER_NOT_USEFUL == ret || \r
 636                 EPS_COM_NOT_RECEIVE == ret ){\r
 637                 ret = EPS_ERR_PRINTER_NOT_FOUND;\r
 638         }\r
 639 \r
 640 /*** Return to Caller                                                                                                                                   */\r
 641 snmpProbeByID_END:\r
 642         snmpFindEnd(sock);\r
 643  \r
 644         if( EPS_ERR_NONE != ret ){\r
 645                 EPS_SAFE_RELEASE( *printer );\r
 646         }\r
 647 \r
 648         EPS_RETURN( ret );\r
 649 }\r
 650 \r
 651 \r
 652 /*******************************************|********************************************/\r
 653 /*                                                                                      */\r
 654 /* Function name:   snmpGetStatus()                                                                 */\r
 655 /*                                                                                      */\r
 656 /* Arguments                                                                            */\r
 657 /* ---------                                                                            */\r
 658 /* Name:        Type:               Description:                                        */\r
 659 /* sock         EPS_SOCKET*         I: SNMP socket                                      */\r
 660 /* address      EPS_INT8*           I: target printer IP Address                        */\r
 661 /* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */\r
 662 /*                                                                                      */\r
 663 /* Return value:                                                                        */\r
 664 /*      EPS_ERR_NONE                    - Success                                       */\r
 665 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
 666 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 667 /*                                                                                      */\r
 668 /* Description:                                                                         */\r
 669 /*      Get the printer status and analyze the status string.                           */\r
 670 /*                                                                                      */\r
 671 /*******************************************|********************************************/\r
 672 EPS_ERR_CODE snmpGetStatus(\r
 673                                                                  \r
 674                 EPS_SOCKET sock, \r
 675                 const EPS_INT8* address, \r
 676                 EPS_STATUS_INFO* pstInfo\r
 677                 \r
 678 ){\r
 679         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 680         ASN_VARIANT pdu;\r
 681         EPS_INT32 retry = 0;\r
 682 \r
 683 EPS_LOG_FUNCIN\r
 684 \r
 685         memset(&pdu, 0, sizeof(pdu));\r
 686 \r
 687         for(retry = 0; retry < EPSNET_STAT_RETRY; retry++){\r
 688                 ret = SnmpTransactS(sock, address, EPSNET_STAT_RECV_TIMEOUT, \r
 689                                                         s_oidPrvStatus, ASN_PDU_GET_NEXT, &pdu);\r
 690                 if(EPS_ERR_NONE == ret ){\r
 691                         break;\r
 692                 }\r
 693                 EPS_REREASE_VARIANT( pdu );\r
 694                 EPS_DBGPRINT(("GetStatus retry %d\n", retry))\r
 695         }\r
 696 \r
 697         if( EPS_ERR_NONE == ret ){\r
 698                 if(ASN_VT_OCTET_STRING == pdu.type){\r
 699                         ret = serAnalyzeStatus(pdu.val.v_str, pstInfo);\r
 700                 } else{\r
 701                         ret = EPS_ERR_COMM_ERROR;\r
 702                 }\r
 703         }\r
 704 \r
 705         EPS_REREASE_VARIANT( pdu );\r
 706 \r
 707         EPS_RETURN( ret )\r
 708 }\r
 709 \r
 710 #ifdef GCOMSW_CMD_ESCPAGE\r
 711 EPS_ERR_CODE snmpGetStatus_Page(\r
 712                                                                  \r
 713                 EPS_SOCKET sock, \r
 714                 const EPS_INT8* address, \r
 715                 EPS_STATUS_INFO* pstInfo\r
 716                 \r
 717 ){\r
 718         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 719         ASN_VARIANT pdu;\r
 720         EPS_INT32   retry = 0;\r
 721         EPS_INT32   devstat, prnstat;\r
 722 \r
 723         EPS_LOG_FUNCIN\r
 724 \r
 725         pstInfo->nState = EPS_ST_IDLE;\r
 726         pstInfo->nError = EPS_PRNERR_NOERROR;\r
 727         pstInfo->nWarn  = EPS_PRNWARN_NONE;\r
 728         pstInfo->nCancel= EPS_CAREQ_NOCANCEL;\r
 729         pstInfo->nInkNo = 0;\r
 730         memset(pstInfo->nColorType, 0, sizeof(pstInfo->nColorType) );\r
 731         memset(pstInfo->nColor, 0, sizeof(pstInfo->nColor) );\r
 732 \r
 733         memset(&pdu, 0, sizeof(pdu));\r
 734 \r
 735         /* get Device Status */\r
 736         for(retry = 0; retry < EPSNET_STAT_RETRY; retry++){\r
 737                 ret = SnmpTransactS(sock, address, EPSNET_STAT_RECV_TIMEOUT, \r
 738                                                         s_oidDevStatus, ASN_PDU_GET_NEXT, &pdu);\r
 739                 if(EPS_ERR_NONE == ret ){\r
 740                         break;\r
 741                 }\r
 742                 EPS_REREASE_VARIANT( pdu );\r
 743                 EPS_DBGPRINT(("GetStatus retry %d\n", retry))\r
 744         }\r
 745         if( EPS_ERR_NONE == ret && ASN_VT_INTEGER == pdu.type){\r
 746                 devstat = pdu.val.v_long;\r
 747         } else{\r
 748                 ret = EPS_ERR_COMM_ERROR;\r
 749                 goto snmpGetStatus_END;\r
 750         }\r
 751         EPS_REREASE_VARIANT( pdu );\r
 752 \r
 753         /* get Printer Status */\r
 754         for(retry = 0; retry < EPSNET_STAT_RETRY; retry++){\r
 755                 ret = SnmpTransactS(sock, address, EPSNET_STAT_RECV_TIMEOUT,\r
 756                                                         s_oidPrinterStatus, ASN_PDU_GET_NEXT, &pdu);\r
 757                 if(EPS_ERR_NONE == ret ){\r
 758                         break;\r
 759                 }\r
 760                 EPS_REREASE_VARIANT( pdu );\r
 761                 EPS_DBGPRINT(("GetStatus retry %d\n", retry))\r
 762         }\r
 763         if( EPS_ERR_NONE == ret && ASN_VT_INTEGER == pdu.type){\r
 764                 prnstat = pdu.val.v_long;\r
 765         } else{\r
 766                 ret = EPS_ERR_COMM_ERROR;\r
 767                 goto snmpGetStatus_END;\r
 768         }\r
 769         EPS_REREASE_VARIANT( pdu );\r
 770 \r
 771         /*EPS_DBGPRINT(("%d / %d\n", devstat, prnstat))*/\r
 772         switch(devstat){\r
 773         case MIB_DEVST_RUNNING:\r
 774         case MIB_DEVST_WARNING:\r
 775                 switch(prnstat){\r
 776                 case MIB_PRNST_IDLE:\r
 777                 case MIB_PRNST_OTHER:   /* Standby */\r
 778                         pstInfo->nState = EPS_ST_IDLE;\r
 779                         pstInfo->nError = EPS_PRNERR_NOERROR;\r
 780                         break;\r
 781                 case MIB_PRNST_PRINTING:\r
 782                         pstInfo->nState = EPS_ST_WAITING;\r
 783                         pstInfo->nError = EPS_PRNERR_NOERROR;\r
 784                         break;\r
 785                 default:\r
 786                 /*case MIB_PRNST_WARMUP:*/\r
 787                         pstInfo->nState = EPS_ST_BUSY;\r
 788                         pstInfo->nError = EPS_PRNERR_BUSY;\r
 789                         break;\r
 790                 }\r
 791                 break;\r
 792 \r
 793         case MIB_DEVST_DOWN:\r
 794                 switch(prnstat){\r
 795                 case MIB_PRNST_WARMUP:\r
 796                         pstInfo->nState = EPS_ST_BUSY;\r
 797                         pstInfo->nError = EPS_PRNERR_BUSY;\r
 798                         break;\r
 799                 default:\r
 800                 /*case MIB_PRNST_OTHER:*/\r
 801                         pstInfo->nState = EPS_ST_ERROR;\r
 802                         pstInfo->nError = EPS_PRNERR_GENERAL;\r
 803                         break;\r
 804                 }\r
 805                 break;\r
 806 \r
 807         default:\r
 808                 pstInfo->nState = EPS_ST_ERROR;\r
 809                 pstInfo->nError = EPS_PRNERR_GENERAL;\r
 810                 break;\r
 811         }\r
 812 \r
 813         if( EPS_ST_ERROR == pstInfo->nState ){\r
 814                 /* get error reason */\r
 815                 for(retry = 0; retry < EPSNET_STAT_RETRY; retry++){\r
 816                         ret = SnmpTransactS(sock, address, EPSNET_STAT_RECV_TIMEOUT, \r
 817                                                                 s_oidPrinterError, ASN_PDU_GET_NEXT, &pdu);\r
 818                         if(EPS_ERR_NONE == ret ){\r
 819                                 break;\r
 820                         }\r
 821                         EPS_REREASE_VARIANT( pdu );\r
 822                         EPS_DBGPRINT(("GetStatus retry %d\n", retry))\r
 823                 }\r
 824 \r
 825                 if( EPS_ERR_NONE == ret && ASN_VT_OCTET_STRING == pdu.type){\r
 826                         EPS_DBGPRINT(("0x%02X\n", pdu.val.v_str[0]))\r
 827                         if( pdu.val.v_str[0] & MIB_PRERR_NOPAPER ){\r
 828                                 pstInfo->nError = EPS_PRNERR_PAPEROUT;\r
 829                         } else if( pdu.val.v_str[0] & MIB_PRERR_NOINK ){\r
 830                                 pstInfo->nError = EPS_PRNERR_INKOUT;\r
 831                         } else if( pdu.val.v_str[0] & MIB_PRERR_COVEROPEN ){\r
 832                                 pstInfo->nError = EPS_PRNERR_COVEROPEN;\r
 833                         } else if( pdu.val.v_str[0] & MIB_PRERR_PAPERJAM ){\r
 834                                 pstInfo->nError = EPS_PRNERR_PAPERJAM;\r
 835                         } else{\r
 836                                 pstInfo->nError = EPS_PRNERR_GENERAL;\r
 837                         }\r
 838                 } else{\r
 839                         ret = EPS_ERR_COMM_ERROR;\r
 840                         goto snmpGetStatus_END;\r
 841                 }\r
 842         }\r
 843 \r
 844 snmpGetStatus_END:\r
 845         EPS_REREASE_VARIANT( pdu );\r
 846 \r
 847         EPS_RETURN( ret )\r
 848 }\r
 849 #endif /* GCOMSW_CMD_ESCPAGE */\r
 850 \r
 851 /*******************************************|********************************************/\r
 852 /*                                                                                      */\r
 853 /* Function name:   snmpGetInkInfo()                                                    */\r
 854 /*                                                                                      */\r
 855 /* Arguments                                                                            */\r
 856 /* ---------                                                                            */\r
 857 /* Name:        Type:               Description:                                        */\r
 858 /* address      EPS_INT8*           I: target printer IP Address                        */\r
 859 /* pstInfo      EPS_STATUS_INFO*    O: Printer Status information                       */\r
 860 /*                                                                                      */\r
 861 /* Return value:                                                                        */\r
 862 /*      EPS_ERR_NONE                    - Success                                       */\r
 863 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
 864 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 865 /*                                                                                      */\r
 866 /* Description:                                                                         */\r
 867 /*      Get the marker info.                                                            */\r
 868 /*                                                                                      */\r
 869 /*******************************************|********************************************/\r
 870 EPS_ERR_CODE snmpGetInkInfo(\r
 871                                                                  \r
 872                 const EPS_INT8* address, \r
 873                 EPS_STATUS_INFO* pstInfo\r
 874                 \r
 875 ){\r
 876         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 877         ASN_VARIANT pdu;\r
 878 \r
 879         EPS_LOG_FUNCIN\r
 880 \r
 881         memset(&pdu, 0, sizeof(pdu));\r
 882 \r
 883         ret = SnmpTransact(address, EPSNET_RECV_TIMEOUT, s_oidPrvStatus, ASN_PDU_GET_NEXT, &pdu);\r
 884 \r
 885         if( EPS_ERR_NONE == ret ){\r
 886                 if(ASN_VT_OCTET_STRING == pdu.type){\r
 887                         ret = serAnalyzeStatus(pdu.val.v_str, pstInfo);\r
 888                 } else{\r
 889                         ret = EPS_ERR_COMM_ERROR;\r
 890                 }\r
 891         }\r
 892 \r
 893         EPS_REREASE_VARIANT( pdu );\r
 894 \r
 895         EPS_RETURN( ret )\r
 896 }\r
 897 \r
 898 #ifdef GCOMSW_CMD_ESCPAGE\r
 899 EPS_ERR_CODE snmpGetInkInfo_Page(\r
 900                                                                  \r
 901                 const EPS_INT8* address, \r
 902                 EPS_STATUS_INFO* pstInfo\r
 903                 \r
 904 ){\r
 905         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
 906         EPS_SOCKET      soc;\r
 907         ASN_VARIANT pdu;\r
 908         EPS_INT32   i;\r
 909 \r
 910         EPS_LOG_FUNCIN\r
 911 \r
 912         pstInfo->nInkNo = 0;\r
 913         memset(&pdu, 0, sizeof(pdu));\r
 914 \r
 915         ret = snmpOpenSocket(&soc);\r
 916         if( EPS_ERR_NONE != ret ){\r
 917                 ret = EPS_ERR_COMM_ERROR;\r
 918                 goto snmpGetInkInfo_END;\r
 919         }\r
 920 \r
 921         /* walk MarkerName record */\r
 922         i = 0;\r
 923         ret = SnmpWalkMib(soc, address, s_oidMarkerColorant, &pdu);\r
 924         while(EPS_ERR_NONE == ret){\r
 925                 if(ASN_VT_OCTET_STRING == pdu.type){\r
 926                         pdu.val.v_str[pdu.length] = '\0';\r
 927                         pstInfo->nColorType[i++] = GetColorID(pdu.val.v_str);\r
 928                 }\r
 929 \r
 930                 /* next */\r
 931                 EPS_REREASE_VARIANT( pdu );\r
 932                 ret = SnmpWalkMib(soc, address, NULL, &pdu);\r
 933         }\r
 934         if(EPS_COM_NEXT_RECORD == ret){\r
 935                 ret = EPS_ERR_NONE;\r
 936         } else if( EPS_ERR_NONE != ret ){\r
 937                 ret = EPS_ERR_COMM_ERROR;\r
 938                 goto snmpGetInkInfo_END;\r
 939         }\r
 940 \r
 941         pstInfo->nInkNo = i;\r
 942 \r
 943         /* walk MarkerLevel record */\r
 944         i = 0;\r
 945         EPS_REREASE_VARIANT( pdu );\r
 946         ret = SnmpWalkMib(soc, address, s_oidMarkerLevel, &pdu);\r
 947         while(EPS_ERR_NONE == ret){\r
 948                 if(ASN_VT_INTEGER == pdu.type){\r
 949                         pstInfo->nColor[i++] = serInkLevelNromalize(pdu.val.v_long);\r
 950                 }\r
 951 \r
 952                 /* next */\r
 953                 EPS_REREASE_VARIANT( pdu );\r
 954                 ret = SnmpWalkMib(soc, address, NULL, &pdu);\r
 955         }\r
 956         if(EPS_COM_NEXT_RECORD == ret){\r
 957                 ret = EPS_ERR_NONE;\r
 958         } else if( EPS_ERR_NONE != ret ){\r
 959                 ret = EPS_ERR_COMM_ERROR;\r
 960                 goto snmpGetInkInfo_END;\r
 961         }\r
 962 \r
 963 snmpGetInkInfo_END:\r
 964         snmpCloseSocket(&soc);\r
 965         EPS_REREASE_VARIANT( pdu );\r
 966 \r
 967         EPS_RETURN( ret )\r
 968 }\r
 969 #endif /* GCOMSW_CMD_ESCPAGE */\r
 970 \r
 971 \r
 972 /*******************************************|********************************************/\r
 973 /*                                                                                      */\r
 974 /* Function name:     snmpGetPMString()                                                                                         */\r
 975 /*                                                                                      */\r
 976 /* Arguments                                                                            */\r
 977 /* ---------                                                                            */\r
 978 /* Name:        Type:               Description:                                        */\r
 979 /* printer      EPS_PRINTER_INN*    I: Pointer to a PrinterInfo                         */\r
 980 /* pString              EPS_UINT8*                      O: Pointer to PM String                             */\r
 981 /* bufSize              EPS_INT32                       I: pString buffer size                              */\r
 982 /*                                                                                      */\r
 983 /* Return value:                                                                                                                                                */\r
 984 /*      EPS_ERR_NONE                                    - Success                                                                               */\r
 985 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
 986 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
 987 /*                                                                                      */\r
 988 /* Description:                                                                         */\r
 989 /*      Sends request to printer for supported media.  Parses response and stores               */\r
 990 /*              PM String : pString                                                             */\r
 991 /*                                                                                      */\r
 992 /*******************************************|********************************************/\r
 993 EPS_ERR_CODE snmpGetPMString(\r
 994                                                                   \r
 995                 const EPS_PRINTER_INN*  printer, \r
 996                 EPS_INT32               type,\r
 997         EPS_UINT8*              pString,\r
 998                 EPS_INT32*              bufSize\r
 999 \r
1000 ){\r
1001         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1002         ASN_VARIANT pdu;\r
1003         EPS_INT8        cOid[SNMP_MAX_OID];\r
1004 \r
1005         EPS_LOG_FUNCIN\r
1006 \r
1007         memset(&pdu, 0, sizeof(pdu));\r
1008 \r
1009         /* Create GetPM command                                                             */\r
1010         if(1 == type){\r
1011                 sprintf(cOid, "%s.1.%d.%d.%d.%d.%d", s_oidPrvCtrl, 'p', 'm', 0x01, 0x00, 0x01);\r
1012         } else if(2 == type){\r
1013                 sprintf(cOid, "%s.1.%d.%d.%d.%d.%d", s_oidPrvCtrl, 'p', 'm', 0x01, 0x00, 0x02);\r
1014         } else{\r
1015                 EPS_RETURN( EPS_ERR_OPR_FAIL )\r
1016         }\r
1017 \r
1018         ret = SnmpTransact(printer->location, EPSNET_RECV_TIMEOUT,  cOid, ASN_PDU_GET, &pdu);\r
1019 \r
1020         if( EPS_ERR_NONE == ret ){\r
1021                 if(ASN_VT_OCTET_STRING == pdu.type){\r
1022                         *bufSize = Min((EPS_UINT32)*bufSize, pdu.length-1);\r
1023                         memcpy(pString, pdu.val.v_str+1, *bufSize);\r
1024                 } else{\r
1025                         ret = EPS_ERR_COMM_ERROR;\r
1026                 }\r
1027         }\r
1028         EPS_REREASE_VARIANT( pdu );\r
1029 \r
1030         EPS_RETURN( ret )\r
1031 }\r
1032 \r
1033 #ifdef GCOMSW_CMD_ESCPAGE\r
1034 EPS_ERR_CODE snmpGetPMString_Page(\r
1035                                                                   \r
1036                 const EPS_PRINTER_INN*  printer, \r
1037                 EPS_INT32               type,\r
1038         EPS_UINT8*              pString,\r
1039                 EPS_INT32*              bufSize\r
1040 \r
1041 ){\r
1042         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1043         ASN_VARIANT pdu;\r
1044         EPS_SOCKET      soc;\r
1045         EPS_UINT32 paperSource = EPS_MPID_AUTO;\r
1046 \r
1047         EPS_LOG_FUNCIN\r
1048 \r
1049         /* walk MarkerLevel record for enum paper tray */\r
1050         *bufSize = 0;\r
1051         ret = snmpOpenSocket(&soc);\r
1052         if( EPS_ERR_NONE != ret ){\r
1053                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1054         }\r
1055 \r
1056         ret = SnmpWalkMib(soc, printer->location, s_oidInputName, &pdu);\r
1057         while(EPS_ERR_NONE == ret){\r
1058                 if(ASN_VT_OCTET_STRING == pdu.type){\r
1059                         if( strncmp(pdu.val.v_str, "MP Tray", pdu.length) == 0 ){\r
1060                                 paperSource |= EPS_MPID_MPTRAY;\r
1061                         } else if( strncmp(pdu.val.v_str, "LC1", pdu.length) == 0 ){\r
1062                                 paperSource |= EPS_MPID_FRONT1;\r
1063                         } else if( strncmp(pdu.val.v_str, "LC2", pdu.length) == 0 ){\r
1064                                 paperSource |= EPS_MPID_FRONT2;\r
1065                         } else if( strncmp(pdu.val.v_str, "LC3", pdu.length) == 0 ){\r
1066                                 paperSource |= EPS_MPID_FRONT3;\r
1067                         } else if( strncmp(pdu.val.v_str, "LC4", pdu.length) == 0 ){\r
1068                                 paperSource |= EPS_MPID_FRONT4;\r
1069                         }\r
1070                 }\r
1071 \r
1072                 /* next */\r
1073                 EPS_REREASE_VARIANT( pdu );\r
1074                 ret = SnmpWalkMib(soc, printer->location, NULL, &pdu);\r
1075         }\r
1076 \r
1077         if(EPS_COM_NEXT_RECORD == ret){\r
1078                 ret = EPS_ERR_NONE;\r
1079         } else if( EPS_ERR_NONE != ret ){\r
1080                 ret = EPS_ERR_COMM_ERROR;\r
1081                 *bufSize = 0;\r
1082         }\r
1083         snmpCloseSocket(&soc);\r
1084 \r
1085         if(EPS_ERR_NONE == ret){\r
1086                 *bufSize = sizeof(EPS_UINT32);\r
1087                 memcpy(pString, &paperSource, sizeof(EPS_UINT32));\r
1088         }\r
1089                 \r
1090         EPS_RETURN( ret )\r
1091 }\r
1092 #endif  /*GCOMSW_CMD_ESCPAGE*/\r
1093 \r
1094 /*******************************************|********************************************/\r
1095 /*                                                                                      */\r
1096 /* Function name:   snmpMechCommand()                                                   */\r
1097 /*                                                                                      */\r
1098 /* Arguments                                                                            */\r
1099 /* ---------                                                                            */\r
1100 /* Name:        Type:               Description:                                        */\r
1101 /* Command      EPS_INT32           I: Command Code                                     */\r
1102 /*                                                                                      */\r
1103 /* Return value:                                                                        */\r
1104 /*      EPS_ERR_NONE                    - Mech command executed successfully            */\r
1105 /*      EPS_ERR_JOB_NOT_INITIALIZED     - JOB is NOT initialized                                                */\r
1106 /*      EPS_ERR_COMM_ERROR              - Mech command execution error                  */\r
1107 /*                                                                                      */\r
1108 /* Description:                                                                         */\r
1109 /*      Sends mechanincal commands to the printer.                                      */\r
1110 /*                                                                                      */\r
1111 /*******************************************|********************************************/\r
1112 EPS_ERR_CODE    snmpMechCommand (\r
1113 \r
1114         const EPS_PRINTER_INN*  printer, \r
1115         EPS_INT32   Command\r
1116         \r
1117 ){\r
1118         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1119         ASN_VARIANT pdu;\r
1120         EPS_INT8        cOid[SNMP_MAX_OID];\r
1121 \r
1122 EPS_LOG_FUNCIN\r
1123         memset(&pdu, 0, sizeof(pdu));\r
1124 \r
1125         /* Create control command */\r
1126         switch( Command ){\r
1127         case EPS_CBTCOM_PE:\r
1128                 sprintf(cOid, "%s.1.%d.%d.%d.%d.%d", s_oidPrvCtrl, 'p', 'e', 0x01, 0x00, 0x01);\r
1129                 break;\r
1130         case EPS_CBTCOM_RJ:\r
1131                 sprintf(cOid, "%s.1.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d.%d", \r
1132                         s_oidPrvCtrl, 'r', 'j', 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\r
1133                          /* E   , S   , C   , P   , R   , L   , i   , b    */\r
1134                             0x45, 0x53, 0x43, 0x50, 0x52, 0x4c, 0x69, 0x62);\r
1135                 break;\r
1136         default:\r
1137                 EPS_RETURN( EPS_ERR_OPR_FAIL )\r
1138         }\r
1139 \r
1140         ret = SnmpTransact(printer->location, EPSNET_RECV_TIMEOUT, cOid, ASN_PDU_GET, &pdu);\r
1141 \r
1142         if( EPS_ERR_NONE == ret ){\r
1143                 EPS_DBGPRINT(("%s\n", pdu.val.v_str+1))\r
1144                 if( (ASN_VT_OCTET_STRING == pdu.type) &&\r
1145                         (strstr(pdu.val.v_str+1,"OK") != NULL) ){\r
1146                         ret = EPS_ERR_NONE;\r
1147                 } else{\r
1148                         ret = EPS_ERR_COMM_ERROR;\r
1149                 }\r
1150         }\r
1151 \r
1152         EPS_REREASE_VARIANT( pdu );\r
1153 \r
1154         EPS_RETURN( ret )\r
1155 }\r
1156 \r
1157 #ifdef GCOMSW_CMD_ESCPAGE\r
1158 EPS_ERR_CODE    snmpMechCommand_Page (\r
1159 \r
1160         const EPS_PRINTER_INN*  printer, \r
1161         EPS_INT32   Command\r
1162         \r
1163 ){\r
1164         EPS_LOG_FUNCIN\r
1165         (void)printer;\r
1166         (void)Command;\r
1167     EPS_RETURN( EPS_ERR_PROTOCOL_NOT_SUPPORTED )\r
1168 }\r
1169 #endif  /*GCOMSW_CMD_ESCPAGE*/\r
1170 \r
1171 \r
1172 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1173 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1174 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
1175 /*--------------------               Local Functions               ---------------------*/\r
1176 /*%%%%%%%%%%%%%%%%%%%%                                             %%%%%%%%%%%%%%%%%%%%%*/\r
1177 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1178 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
1179 \r
1180 /*******************************************|********************************************/\r
1181 /*                                                                                      */\r
1182 /* Function name:     SnmpTransact()                                                                                                    */\r
1183 /*                                                                                      */\r
1184 /* Arguments                                                                            */\r
1185 /* ---------                                                                            */\r
1186 /* Name:        Type:               Description:                                        */\r
1187 /* address      EPS_INT8*           I: Destination IP Address string (NULL terminate)   */\r
1188 /* recvtimeout  EPS_UINT32          I: receive response timeout                         */\r
1189 /* oid          EPS_INT8*           I: Object ID                                        */\r
1190 /* request              EPS_INT8**                  I: Request type                                     */\r
1191 /* pdu          ASN_VARIANT*        O: recieved value                                   */\r
1192 /*                                                                                      */\r
1193 /* Return value:                                                                                                                                                */\r
1194 /*      EPS_ERR_NONE                                    - Success                                                   */\r
1195 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1196 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1197 /*      EPS_COM_TINEOUT                 - Receive timeout                               */\r
1198 /*                                                                                      */\r
1199 /* Description:                                                                         */\r
1200 /*      SNMP send request and receive responce transaction.                                                             */\r
1201 /*                                                                                      */\r
1202 /*******************************************|********************************************/\r
1203 static EPS_ERR_CODE SnmpTransact(\r
1204                                                                  \r
1205                 const EPS_INT8* address, \r
1206                 EPS_INT32  recvtimeout,\r
1207                 const EPS_INT8* oid, \r
1208                 EPS_UINT8       request,\r
1209                 ASN_VARIANT*    pdu\r
1210                 \r
1211 ){\r
1212         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1213         EPS_SOCKET   soc;\r
1214 \r
1215 EPS_LOG_FUNCIN\r
1216 \r
1217         ret = snmpOpenSocket(&soc);\r
1218         if( EPS_ERR_NONE != ret ){\r
1219                 EPS_RETURN( ret )\r
1220         }\r
1221 \r
1222         ret = SnmpTransactS(soc, address, recvtimeout, oid, request, pdu);\r
1223 \r
1224         snmpCloseSocket(&soc);\r
1225 \r
1226         EPS_RETURN( ret )\r
1227 }\r
1228 \r
1229 \r
1230 static EPS_ERR_CODE SnmpTransactS(\r
1231                                                                  \r
1232                 EPS_SOCKET sock, \r
1233                 const EPS_INT8* address, \r
1234                 EPS_INT32  recvtimeout,\r
1235                 const EPS_INT8* oid, \r
1236                 EPS_UINT8       request,\r
1237                 ASN_VARIANT* pdu\r
1238                 \r
1239 ){\r
1240         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1241         EPS_UINT8       nRqID = 0;\r
1242         EPS_INT32       nSize = 0;\r
1243         EPS_INT32       nRecvSize = 0;\r
1244 \r
1245 EPS_LOG_FUNCIN\r
1246 \r
1247         memset(pdu, 0, sizeof(ASN_VARIANT));\r
1248 \r
1249         /* Create GetStatus command                                                                                                                     */\r
1250         nRqID = GetRequestId();\r
1251         if( EPS_ERR_NONE != (ret = CreateCommand(g_TrnBuff, request, nRqID,\r
1252                                                                                 oid, &nSize)) ){\r
1253                 EPS_RETURN( ret )\r
1254         }\r
1255 \r
1256         /* Send                                                                                                                                                         */\r
1257         if( epsNetFnc.sendTo(sock, (char*)g_TrnBuff, nSize, \r
1258                                                 address, SNMP_PORT_NUM, EPSNET_SEND_TIMEOUT) <= 0 ){\r
1259                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1260         }\r
1261 \r
1262         ret = EPS_COM_READ_MORE;\r
1263         while(ret == EPS_COM_READ_MORE){\r
1264                 /* Wireless network always send pair message and receive. \r
1265                    This behave make probrem that receive befor message. If it occur, try receive once.*/\r
1266                 nRecvSize = epsNetFnc.receive( sock, g_TrnBuff, SNMP_MAX_BUF, recvtimeout ); \r
1267                 if( 0 >= nRecvSize ){                                                   /* Error Occur or Not Recieve   */\r
1268                         EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1269                 }\r
1270                 ret = GetPDU(g_TrnBuff, nRecvSize, nRqID, oid, pdu, NULL, 0);\r
1271         }\r
1272 \r
1273         if( EPS_ERR_NONE != ret ){\r
1274                 EPS_REREASE_VARIANT( *pdu );\r
1275                 if(EPS_COM_NEXT_RECORD == ret){\r
1276                         ret = EPS_ERR_COMM_ERROR;\r
1277                 }\r
1278         }\r
1279 \r
1280         EPS_RETURN( ret )\r
1281 }\r
1282 \r
1283 \r
1284 /*******************************************|********************************************/\r
1285 /*                                                                                      */\r
1286 /* Function name:     SnmpWalkMib()                                                                                                 */\r
1287 /*                                                                                      */\r
1288 /* Arguments                                                                            */\r
1289 /* ---------                                                                            */\r
1290 /* Name:        Type:               Description:                                        */\r
1291 /* sock             EPS_SOCKET          I: Socket                                           */\r
1292 /* address      EPS_INT8*           I: Destination IP Address string (NULL terminate)   */\r
1293 /* oid          EPS_INT8*           I: Object ID. set first time only.                  */\r
1294 /* pdu          ASN_VARIANT*        O: recieved value                                   */\r
1295 /*                                                                                      */\r
1296 /* Return value:                                                                                                                                                */\r
1297 /*      EPS_ERR_NONE                                    - Success                                                   */\r
1298 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1299 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1300 /*      EPS_COM_TINEOUT                 - Receive timeout                               */\r
1301 /*                                                                                      */\r
1302 /* Description:                                                                         */\r
1303 /*      SNMP walk mib record transaction.                                                                               */\r
1304 /*                                                                                      */\r
1305 /*******************************************|********************************************/\r
1306 static EPS_ERR_CODE SnmpWalkMib(\r
1307                                                                  \r
1308                 EPS_SOCKET sock, \r
1309                 const EPS_INT8* address, \r
1310                 const EPS_INT8* oid, \r
1311                 ASN_VARIANT*    pdu\r
1312                 \r
1313 ){\r
1314         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1315         EPS_UINT8       nRqID = 0;\r
1316         EPS_INT32       nSize = 0;\r
1317         EPS_INT32       nRecvSize = 0;\r
1318         static EPS_INT8    orgObjID[SNMP_OBJID_LEN];\r
1319         static EPS_INT8    nextObjID[SNMP_OBJID_LEN];\r
1320 \r
1321 EPS_LOG_FUNCIN\r
1322 \r
1323         memset(pdu, 0, sizeof(ASN_VARIANT));\r
1324 \r
1325         /* Create command */\r
1326         nRqID = GetRequestId();\r
1327         if( oid ){\r
1328                 strcpy(orgObjID, oid);\r
1329                 strcpy(nextObjID, oid);\r
1330         }\r
1331         ret = CreateCommand(g_TrnBuff, ASN_PDU_GET_NEXT, nRqID, nextObjID, &nSize);\r
1332         if( EPS_ERR_NONE != ret){\r
1333                 EPS_RETURN( ret )\r
1334         }\r
1335 \r
1336         /* Send */\r
1337         if( epsNetFnc.sendTo(sock, (char*)g_TrnBuff, nSize, \r
1338                                                 address, SNMP_PORT_NUM, EPSNET_SEND_TIMEOUT) <= 0 ){\r
1339                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1340         }\r
1341 \r
1342         ret = EPS_COM_READ_MORE;\r
1343         while(ret == EPS_COM_READ_MORE){\r
1344                 /* Wireless network always send pair message and receive. \r
1345                    This behave make probrem that receive befor message. If it occur, try receive once.*/\r
1346                 nRecvSize = epsNetFnc.receive( sock, g_TrnBuff, SNMP_MAX_BUF, EPSNET_RECV_TIMEOUT ); \r
1347                 if( 0 >= nRecvSize ){                                                   /* Error Occur or Not Recieve   */\r
1348                         EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1349                 }\r
1350                 ret = GetPDU(g_TrnBuff, nRecvSize, nRqID, orgObjID, pdu, nextObjID, SNMP_OBJID_LEN);\r
1351         }\r
1352 \r
1353         if( EPS_ERR_NONE != ret ){\r
1354                 EPS_REREASE_VARIANT( *pdu );\r
1355         }\r
1356 \r
1357         EPS_RETURN( ret )\r
1358 }\r
1359 \r
1360 \r
1361 /*******************************************|********************************************/\r
1362 /*                                                                                      */\r
1363 /* Function name:     mibGetPhysAddress()                                                                                               */\r
1364 /*                                                                                      */\r
1365 /* Arguments                                                                            */\r
1366 /* ---------                                                                            */\r
1367 /* Name:        Type:               Description:                                        */\r
1368 /* address      EPS_INT8*           I: Destination IP Address string (NULL terminate)   */\r
1369 /* val          EPS_INT8*           O: pointer to return value                          */\r
1370 /* vallen               EPS_UINT32                  I: lenght of val buffer                             */\r
1371 /*                                                                                      */\r
1372 /* Return value:                                                                                                                                                */\r
1373 /*      EPS_ERR_NONE                                    - Success                                                   */\r
1374 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1375 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1376 /*      EPS_COM_TINEOUT                 - Receive timeout                               */\r
1377 /*                                                                                      */\r
1378 /* Description:                                                                         */\r
1379 /*      Get MacAddress.                                                                                                                                 */\r
1380 /*                                                                                      */\r
1381 /*******************************************|********************************************/\r
1382 static EPS_ERR_CODE mibGetPhysAddress(\r
1383                                                                  \r
1384                 const EPS_INT8* address, \r
1385                 EPS_INT8*               val, \r
1386                 EPS_UINT32              vallen \r
1387                 \r
1388 ){\r
1389         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1390         ASN_VARIANT  pdu;\r
1391         EPS_UINT8    *p;\r
1392         EPS_UINT32       i;\r
1393 \r
1394         EPS_LOG_FUNCIN\r
1395 \r
1396         memset(&pdu, 0, sizeof(pdu));\r
1397         ret = SnmpTransact(address, EPSNET_RECV_TIMEOUT, s_oidPhysAddress, ASN_PDU_GET_NEXT, &pdu);\r
1398 \r
1399         if( EPS_ERR_NONE != ret ){\r
1400                 ret = EPS_ERR_COMM_ERROR;\r
1401                 goto mibGetPhysAddress_END;\r
1402         }\r
1403         if(ASN_VT_OCTET_STRING != pdu.type){\r
1404                 ret = EPS_ERR_COMM_ERROR;\r
1405                 goto mibGetPhysAddress_END;\r
1406         }\r
1407 \r
1408         /* convert to string */\r
1409         p = (EPS_UINT8*)val;\r
1410         vallen -= 2;\r
1411         for(i = 0; i < pdu.length && i < vallen; i++ ){\r
1412                 *p = ((EPS_UINT8)pdu.val.v_str[i] >> 4);\r
1413                 if(*p < 10){\r
1414                         *p += 0x30;\r
1415                 } else{\r
1416                         *p += 0x37;\r
1417                 }\r
1418                 p++;\r
1419 \r
1420                 *p = ((EPS_UINT8)pdu.val.v_str[i] & 0x0F);\r
1421                 if(*p < 10){\r
1422                         *p += 0x30;\r
1423                 } else{\r
1424                         *p += 0x37;\r
1425                 }\r
1426                 p++;\r
1427         }\r
1428         *p = '\0';\r
1429 \r
1430 mibGetPhysAddress_END:\r
1431         EPS_REREASE_VARIANT( pdu );\r
1432 \r
1433         EPS_RETURN( ret )\r
1434 }\r
1435 \r
1436 \r
1437 /*******************************************|********************************************/\r
1438 /*                                                                                      */\r
1439 /* Function name:     mibConfirmPrintPort()                                                                                     */\r
1440 /*                                                                                      */\r
1441 /* Arguments                                                                            */\r
1442 /* ---------                                                                            */\r
1443 /* Name:        Type:               Description:                                        */\r
1444 /* printPort    EPS_UINT16                  I: print port                                       */\r
1445 /*                                                                                      */\r
1446 /* Return value:                                                                                                                                                */\r
1447 /*      EPS_ERR_NONE                                    - Success                                                   */\r
1448 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1449 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1450 /*      EPS_COM_TINEOUT                 - Receive timeout                               */\r
1451 /*      EPS_COM_NEXT_RECORD             - got next recode                               */\r
1452 /*                                                                                      */\r
1453 /* Description:                                                                         */\r
1454 /*      Confirm whether can use Print-port.                                                                                             */\r
1455 /*                                                                                      */\r
1456 /*******************************************|********************************************/\r
1457 static EPS_ERR_CODE mibConfirmPrintPort(\r
1458                                                 \r
1459                 const EPS_INT8* address, \r
1460                 EPS_UINT16              printPort \r
1461                 \r
1462 ){\r
1463         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1464         EPS_SOCKET       sckTmp;\r
1465         ASN_VARIANT  pdu;\r
1466 \r
1467         EPS_LOG_FUNCIN\r
1468                 \r
1469         ret = snmpOpenSocket(&sckTmp);\r
1470         if( EPS_ERR_NONE != ret ){\r
1471                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1472         }\r
1473 \r
1474         /* walk Tcp port record */\r
1475         ret = SnmpWalkMib(sckTmp, address, s_oidTcpConnLocalPort, &pdu);\r
1476         while(EPS_ERR_NONE == ret){\r
1477                 if(ASN_VT_INTEGER == pdu.type){\r
1478                         EPS_DBGPRINT(("pdu.val.v_long = %d, %d\n", printPort, pdu.val.v_long));\r
1479                         if( printPort == pdu.val.v_long) {\r
1480                                 break;\r
1481                         }\r
1482                 }\r
1483                 /* next */\r
1484                 EPS_REREASE_VARIANT( pdu );\r
1485                 ret = SnmpWalkMib(sckTmp, address, NULL, &pdu);\r
1486         }\r
1487 \r
1488         EPS_REREASE_VARIANT( pdu );\r
1489         snmpCloseSocket(&sckTmp);\r
1490 \r
1491         EPS_RETURN( ret )\r
1492 }\r
1493 \r
1494 \r
1495 #ifdef GCOMSW_CMD_ESCPAGE_S\r
1496 /*******************************************|********************************************/\r
1497 /*                                                                                      */\r
1498 /* Function name:     mibGetMaxMediaXFeedDir()                                                                                  */\r
1499 /*                                                                                      */\r
1500 /* Arguments                                                                            */\r
1501 /* ---------                                                                            */\r
1502 /* Name:        Type:               Description:                                        */\r
1503 /* address      EPS_INT8*           I: Destination IP Address string (NULL terminate)   */\r
1504 /* val          EPS_INT8*           O: pointer to return value                          */\r
1505 /* vallen               EPS_UINT32                  I: lenght of val buffer                             */\r
1506 /*                                                                                      */\r
1507 /* Return value:                                                                                                                                                */\r
1508 /*      EPS_ERR_NONE                                    - Success                                                   */\r
1509 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1510 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1511 /*      EPS_COM_TINEOUT                 - Receive timeout                               */\r
1512 /*                                                                                      */\r
1513 /* Description:                                                                         */\r
1514 /*      Get MacAddress.                                                                                                                                 */\r
1515 /*                                                                                      */\r
1516 /*******************************************|********************************************/\r
1517 static EPS_ERR_CODE mibGetMaxMediaXFeedDir(\r
1518                                                                  \r
1519                 const EPS_INT8* address, \r
1520                 EPS_UINT32*             val \r
1521                 \r
1522 ){\r
1523         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1524         ASN_VARIANT  pdu;\r
1525         /* iso(1) org(3) dod(6) internet(1) mgmt(2) mib-2(1) printmib(43) prtMediaPath(13)\r
1526       prtMediaPathTable(4) prtMediaPathEntry(1) prtMediaPathMaxMediaXFeedDir(6) */\r
1527         const EPS_INT8 oidMaxMediaXFeedDir[]    = "1.3.6.1.2.1.43.13.4.1.6";\r
1528 \r
1529         EPS_LOG_FUNCIN\r
1530 \r
1531         *val = 0;\r
1532 \r
1533         memset(&pdu, 0, sizeof(pdu));\r
1534         ret = SnmpTransact(address, EPSNET_RECV_TIMEOUT, oidMaxMediaXFeedDir, ASN_PDU_GET_NEXT, &pdu);\r
1535 \r
1536         if( EPS_ERR_NONE != ret ){\r
1537                 ret = EPS_ERR_COMM_ERROR;\r
1538                 goto mibGetMaxMediaXFeedDir_END;\r
1539         }\r
1540         if(ASN_VT_INTEGER != pdu.type){\r
1541                 ret = EPS_ERR_COMM_ERROR;\r
1542                 goto mibGetMaxMediaXFeedDir_END;\r
1543         }\r
1544 \r
1545         *val = pdu.val.v_long;\r
1546 \r
1547 mibGetMaxMediaXFeedDir_END:\r
1548         EPS_REREASE_VARIANT( pdu );\r
1549 \r
1550         EPS_RETURN( ret )\r
1551 }\r
1552 #endif\r
1553 \r
1554 \r
1555 /*******************************************|********************************************/\r
1556 /*                                                                                      */\r
1557 /* Function name:     SnmpFindRecv()                                                    */\r
1558 /*                                                                                      */\r
1559 /* Arguments                                                                            */\r
1560 /* ---------                                                                            */\r
1561 /* Name:        Type:               Description:                                        */\r
1562 /* sock             EPS_SOCKET          I: socket used in discovery phase                       */\r
1563 /* printPort    EPS_UINT16          I: print data sending port                          */\r
1564 /* printProtocol EPS_INT32          I: print protocol                                   */\r
1565 /* compSysName          EPS_INT8*       I: unique ID of target printer                      */\r
1566 /* compName             EPS_INT8*           I: model name of target printer                     */\r
1567 /* printer              EPS_PRINTER_INN**   O: pointer for found printer structure              */\r
1568 /*                                                                                      */\r
1569 /* Return value:                                                                        */\r
1570 /*      EPS_ERR_NONE                                    - Success                                           */\r
1571 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1572 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1573 /*      EPS_ERR_PRINTER_NOT_FOUND       - printer not found                             */\r
1574 /*      EPS_ERR_PRINTER_NOT_USEFUL      - received but not usefl                        */\r
1575 /*                                                                                      */\r
1576 /* Description:                                                                         */\r
1577 /*      Read discoverySocket and store information of valid devices that responded to   */\r
1578 /*              discovery message.                                                                                                                              */\r
1579 /*                                                                                      */\r
1580 /*******************************************|********************************************/\r
1581 static EPS_ERR_CODE SnmpFindRecv(\r
1582 \r
1583                 EPS_SOCKET                      sock,\r
1584                 EPS_UINT16                      printPort,\r
1585                 EPS_INT32                       printProtocol,\r
1586                 const EPS_INT8*     compSysName,\r
1587                 const EPS_INT8*     compName,\r
1588                 EPS_PRINTER_INN**   printer\r
1589 \r
1590 ){\r
1591         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1592         EPS_INT8    *pRecvBuf = NULL;                                           /* Receive Buffer                               */\r
1593         EPS_INT32   nRecvSize = 0;                                                      /* Received Length                              */\r
1594         ASN_VARIANT pdu;\r
1595         EPS_INT8    sFromAdder[EPS_ADDR_BUFFSIZE];                      /* Remote Address                               */\r
1596         EPS_UINT16  nFromPort = 0;                                                      /* Remote Port                                  */\r
1597         EPS_INT32       cmdLevel = 0;\r
1598         EPS_INT8    idString[EPS_PRNID_BUFFSIZE];\r
1599         EPS_INT8    devidString[SNMP_MAX_BUF];\r
1600 \r
1601         EPS_LOG_FUNCIN\r
1602 \r
1603         memset(&pdu, 0, sizeof(pdu));\r
1604 \r
1605         pRecvBuf = (EPS_INT8*)EPS_ALLOC( SNMP_MAX_BUF );\r
1606         if( NULL == pRecvBuf ){\r
1607                 EPS_RETURN( EPS_ERR_MEMORY_ALLOCATION );\r
1608         }\r
1609         memset(sFromAdder, 0, sizeof(sFromAdder));\r
1610 \r
1611         /* -------------------------------------------------------------------------------- */\r
1612         /* Recieve discover response                                                                                                            */\r
1613         nRecvSize = epsNetFnc.receiveFrom( sock, pRecvBuf, SNMP_MAX_BUF, \r
1614                                                                 sFromAdder, &nFromPort,\r
1615                                                                 EPSNET_FIND_RECV_TIMEOUT); \r
1616         if( 0 >= nRecvSize ){                   /* Error Occur or No response*/\r
1617                 ret = EPS_COM_NOT_RECEIVE;\r
1618                 goto SnmpFindRecv_END;\r
1619         }\r
1620         /* Existing check */\r
1621         EPS_DBGPRINT(("%s\n", sFromAdder))\r
1622         if( prtIsRegistered(sFromAdder, NULL, printProtocol) ){\r
1623                 ret = EPS_ERR_PRINTER_NOT_FOUND;\r
1624                 goto SnmpFindRecv_END;\r
1625         }\r
1626 \r
1627         /* parse value */\r
1628         ret = GetPDU(pRecvBuf, nRecvSize, 0, s_oidPrvPrinter, &pdu, NULL, 0);\r
1629         if( EPS_COM_ERR_REPLY   == ret ||\r
1630                 EPS_COM_READ_MORE   == ret ||\r
1631                 EPS_COM_NEXT_RECORD == ret ||\r
1632                 EPS_ERR_COMM_ERROR  == ret ){\r
1633                 ret = EPS_ERR_PRINTER_NOT_USEFUL;\r
1634         }\r
1635         if( EPS_ERR_NONE != ret ){\r
1636                 goto SnmpFindRecv_END;\r
1637         }\r
1638         if (pdu.type != ASN_VT_OCTET_STRING) {\r
1639                 ret = EPS_ERR_PRINTER_NOT_USEFUL;\r
1640                 goto SnmpFindRecv_END;\r
1641         }\r
1642         memset(devidString, 0, sizeof(devidString));\r
1643         strncpy(devidString, pdu.val.v_str, Min(pdu.length, SNMP_MAX_BUF-1));\r
1644         devidString[Min(pdu.length, SNMP_MAX_BUF-1)] = 0;\r
1645 \r
1646         /* Create printer data                                                                                                                      */\r
1647         *printer = (EPS_PRINTER_INN*)EPS_ALLOC( sizeof(EPS_PRINTER_INN) );\r
1648         if(NULL == *printer){\r
1649                 ret = EPS_ERR_MEMORY_ALLOCATION;\r
1650                 goto SnmpFindRecv_END;\r
1651         }\r
1652         memset( *printer, 0, sizeof(EPS_PRINTER_INN) );\r
1653 \r
1654         if( !serParseDeviceID(devidString, (*printer)->manufacturerName, (*printer)->modelName, \r
1655                                                                                 &cmdLevel, &(*printer)->language) ){\r
1656                 ret = EPS_ERR_PRINTER_NOT_USEFUL;                               /* Not ESC/P-R,ESC/Page Printer */\r
1657                 goto SnmpFindRecv_END;\r
1658         }\r
1659         if( EPS_PROTOCOL_LPR != printProtocol ){\r
1660                 if( EPS_LANG_ESCPR != (*printer)->language ){\r
1661                         ret = EPS_ERR_PRINTER_NOT_USEFUL;       /* Page Printer Not support via Raw */\r
1662                         goto SnmpFindRecv_END;\r
1663                 }\r
1664         }\r
1665 \r
1666         switch(cmdLevel){\r
1667         case 0: /* Support all. For Uin communication  */\r
1668         case 2:\r
1669                 (*printer)->supportFunc |= EPS_SPF_JPGPRINT; /* Jpeg print */\r
1670         case 1:\r
1671                 (*printer)->supportFunc |= EPS_SPF_RGBPRINT; /* RGB print */\r
1672         }\r
1673 \r
1674         (*printer)->protocol = printProtocol;\r
1675         (*printer)->printPort = printPort;\r
1676         strcpy( (*printer)->location, sFromAdder );\r
1677 \r
1678         /* confirm whether can use Print-port */\r
1679         if( 0 != printPort && EPS_LANG_ESCPR == (*printer)->language){\r
1680                 EPS_DBGPRINT(("mibConfirmPrintPort\n"))\r
1681                 ret = mibConfirmPrintPort(sFromAdder, printPort);\r
1682                 if( EPS_ERR_NONE != ret ){\r
1683                         ret = EPS_ERR_PRINTER_NOT_USEFUL;\r
1684                         goto SnmpFindRecv_END;\r
1685                 }\r
1686         }\r
1687 \r
1688         /* Get mac address */\r
1689         ret = mibGetPhysAddress(sFromAdder, (*printer)->macAddress, sizeof((*printer)->macAddress));\r
1690         if(EPS_ERR_NONE != ret){\r
1691                 ret = EPS_ERR_PRINTER_NOT_USEFUL;\r
1692                 goto SnmpFindRecv_END;\r
1693         }\r
1694         \r
1695         if( NULL != compSysName && NULL != compName){\r
1696                 /* compaire name */\r
1697                 if( strcmp(compSysName, (*printer)->macAddress) ||\r
1698                         strcmp(compName, (*printer)->modelName) ){\r
1699 \r
1700                         ret = EPS_ERR_PRINTER_NOT_USEFUL;\r
1701                         goto SnmpFindRecv_END;\r
1702                 }\r
1703         }\r
1704 \r
1705         /* Get friendly name */\r
1706         EPS_REREASE_VARIANT( pdu );\r
1707         ret = SnmpTransact(sFromAdder, EPSNET_RECV_TIMEOUT, s_oidPrvBonjourName, ASN_PDU_GET_NEXT, &pdu);\r
1708         if( EPS_ERR_NONE == ret && ASN_VT_OCTET_STRING == pdu.type){\r
1709                 if(pdu.length < EPS_NAME_BUFFSIZE-1){\r
1710                         strncpy( (*printer)->friendlyName, pdu.val.v_str, pdu.length);\r
1711                 } else{\r
1712                         strncpy( (*printer)->friendlyName, pdu.val.v_str, EPS_NAME_BUFFSIZE-2);\r
1713                 }\r
1714         } else{\r
1715                 ret = EPS_ERR_NONE; /* ignoure */\r
1716         }\r
1717 \r
1718         sprintf(idString, EPS_NET_IDPRM_STR, (*printer)->modelName, (*printer)->macAddress);\r
1719         prtSetIdStr(*printer, idString);\r
1720 \r
1721 #ifdef GCOMSW_CMD_ESCPAGE_S\r
1722         if(EPS_LANG_ESCPAGE_S == (*printer)->language){\r
1723                 EPS_UINT32 feed = 0;\r
1724                 if( EPS_ERR_NONE == mibGetMaxMediaXFeedDir(sFromAdder, &feed) ){\r
1725                         (*printer)->feedDir = pageS_ParseFeedDir(feed);\r
1726                 }\r
1727         }\r
1728 #endif\r
1729 \r
1730 /*** Return to Caller                                                                   */\r
1731 SnmpFindRecv_END:\r
1732         EPS_REREASE_VARIANT( pdu );\r
1733         EPS_SAFE_RELEASE( pRecvBuf );\r
1734         if(EPS_ERR_NONE != ret){\r
1735                 EPS_SAFE_RELEASE( *printer );\r
1736         }\r
1737 \r
1738         EPS_RETURN( ret )\r
1739 }\r
1740 \r
1741 \r
1742 /*******************************************|********************************************/\r
1743 /*                                                                                      */\r
1744 /* Function name:     CreateCommand()                                                   */\r
1745 /*                                                                                      */\r
1746 /* Arguments                                                                            */\r
1747 /* ---------                                                                            */\r
1748 /* Name:        Type:               Description:                                        */\r
1749 /* pBuf         EPS_INT8*           O: SNMP request buffer                              */\r
1750 /* nPDUType     EPS_UINT8           I: PDU type                                         */\r
1751 /* nRqID        EPS_UINT8           I: SNMP request ID                                  */\r
1752 /* psIdentifire EPS_INT8*           I: MIB number string                                */\r
1753 /* pDataSize    EPS_INT32*          O: SNMP request buffer size                         */\r
1754 /*                                                                                      */\r
1755 /* Return value:                                                                        */\r
1756 /*      EPS_ERR_NONE                                    - Success                                           */\r
1757 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1758 /*                                                                                      */\r
1759 /* Description:                                                                         */\r
1760 /*      Create SNMP request command.                                                    */\r
1761 /*                                                                                      */\r
1762 /*******************************************|********************************************/\r
1763 static EPS_ERR_CODE  CreateCommand(\r
1764                                                                    \r
1765                 EPS_INT8*   pBuff, \r
1766                 EPS_UINT8   nPDUType, \r
1767                 EPS_UINT8   nRqID, \r
1768                 const EPS_INT8*   psIdentifire, \r
1769                 EPS_INT32*  pDataSize\r
1770                 \r
1771 ){\r
1772         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1773         EPS_INT8*       pPos = pBuff;\r
1774         EPS_INT8*       pPDUTop = NULL;\r
1775         EPS_INT8*       pObjTop = NULL;\r
1776         EPS_UINT32      nLen = 0;\r
1777 \r
1778         /* version */\r
1779         pPos = MakeIntField(SNMP_VERSION, pPos);\r
1780         /* Community */\r
1781         pPos = MakeStrField(SNMP_COMMUNITY_STR, pPos);\r
1782         /* PDU Type */\r
1783         *(pPos++) = nPDUType;\r
1784         pPDUTop = pPos;\r
1785 \r
1786         /* Request ID */\r
1787         pPos = MakeIntField(nRqID, pPos);\r
1788         /* Error Index */\r
1789         pPos = MakeIntField(0, pPos);\r
1790         /* Error Status */\r
1791         pPos = MakeIntField(0, pPos);\r
1792         pObjTop = pPos;\r
1793 \r
1794         /* OID */\r
1795         ret = MakeOidField(psIdentifire, &pPos);\r
1796         /* Value(NULL) */\r
1797         *(pPos++) = ASN_VT_NULL;\r
1798         *(pPos++) = (EPS_INT8)(0);\r
1799 \r
1800         /* Set Object Seupence */\r
1801         nLen = (EPS_UINT32)(pPos - pObjTop);\r
1802         ret = MakeSequens(pObjTop, &nLen, TRUE);\r
1803         ret = MakeSequens(pObjTop, &nLen, TRUE);\r
1804 \r
1805         /* Set Object Seupence */\r
1806         nLen = (EPS_UINT32)(pObjTop - pPDUTop) + nLen;\r
1807         ret = MakeSequens(pPDUTop, &nLen, FALSE);\r
1808 \r
1809         /* Set All Seupence */\r
1810         nLen = (EPS_UINT32)(pPDUTop - pBuff) + nLen;\r
1811         ret = MakeSequens(pBuff, &nLen, TRUE);\r
1812 \r
1813         *pDataSize = nLen;\r
1814 \r
1815         return  ret;\r
1816 }\r
1817 \r
1818 \r
1819 /*******************************************|********************************************/\r
1820 /*                                                                                      */\r
1821 /* Function name:     GetPDU()                                                          */\r
1822 /*                                                                                      */\r
1823 /* Arguments                                                                            */\r
1824 /* ---------                                                                            */\r
1825 /* Name:        Type:               Description:                                        */\r
1826 /* pBuf         EPS_INT8*           I: SNMP reply buffer                                */\r
1827 /* nBufSize     EPS_INT32           I: SNMP reply buffer size                           */\r
1828 /* nRqID        EPS_UINT8           I: SNMP request ID                                  */\r
1829 /* pObjID       EPS_INT8*           I: requested OID                                    */\r
1830 /* pPDU         ASN_VARIANT*        O: PDU field structure                              */\r
1831 /* pResObjID    EPS_INT8*           O: response OID                                     */\r
1832 /* nResObjIDSize EPS_INT8*          I: size of pResObjID buffer                         */\r
1833 /*                                                                                      */\r
1834 /* Return value:                                                                        */\r
1835 /*      EPS_ERR_NONE                                    - Success                                           */\r
1836 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1837 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1838 /*                                                                                      */\r
1839 /* Description:                                                                         */\r
1840 /*      Get PDU from SNMP reply.                                                        */\r
1841 /*                                                                                      */\r
1842 /*******************************************|********************************************/\r
1843 static EPS_ERR_CODE GetPDU(\r
1844                                                    \r
1845                 EPS_INT8*   pBuf, \r
1846                 EPS_INT32   nBufSize,\r
1847                 EPS_UINT8   nRqID, \r
1848                 const EPS_INT8*   pObjID, \r
1849                 ASN_VARIANT *pPDU,\r
1850                 EPS_INT8*   pResObjID, \r
1851                 EPS_INT32   nResObjIDSize\r
1852 \r
1853 ){\r
1854         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
1855         EPS_UINT32      nAllSize = 0;\r
1856         EPS_UINT32      nSeqSize = 0;\r
1857         ASN_VARIANT     vField;\r
1858         EPS_INT32   nDataSize = nBufSize;\r
1859         const EPS_INT8 *pOrg, *pRes;\r
1860 \r
1861 #define SNMP_CHECK_INTVALUE( r, v, n )                                                          \\r
1862         if(EPS_ERR_NONE != r ){                                                                                 \\r
1863                 EPS_RETURN( r )                                                                                         \\r
1864         } else  if( ASN_VT_INTEGER != v.type || n != v.val.v_long ){    \\r
1865                 EPS_DBGPRINT(("type=%d / value=%d\n", v.type, v.val.v_long)) \\r
1866                 EPS_REREASE_VARIANT( v );                                                                       \\r
1867                 EPS_RETURN( EPS_ERR_COMM_ERROR )                                                        \\r
1868         }\r
1869 \r
1870 EPS_LOG_FUNCIN\r
1871 \r
1872         vField.length = 0;\r
1873         vField.type = ASN_VT_NULL;\r
1874         vField.val.v_str = NULL;\r
1875 \r
1876         /* skip top tag */\r
1877         pBuf++; \r
1878         nDataSize--;\r
1879         if( EPS_ERR_NONE != (ret = ParseLength( &pBuf, &nDataSize, &nAllSize ) ) ){\r
1880                 EPS_RETURN( ret )\r
1881         }\r
1882 \r
1883         /* check version */\r
1884         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1885         SNMP_CHECK_INTVALUE( ret, vField, SNMP_VERSION );\r
1886 \r
1887         /* check community */\r
1888         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1889         if( ASN_VT_OCTET_STRING != vField.type \r
1890                 || NULL == memStrStrWithLen(vField.val.v_str, vField.length, SNMP_COMMUNITY_STR) ){\r
1891                 EPS_REREASE_VARIANT( vField );\r
1892                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1893         }\r
1894         EPS_REREASE_VARIANT( vField );\r
1895         \r
1896         /* check PDU Type */\r
1897         if( (EPS_UINT8)(*pBuf) != ASN_PDU_RESP ){\r
1898                 EPS_RETURN( EPS_ERR_COMM_ERROR )\r
1899         }\r
1900         pBuf += 1;\r
1901         nDataSize--;\r
1902         /* skip sequence size */\r
1903         if( EPS_ERR_NONE != (ret = ParseLength( &pBuf, &nDataSize, &nSeqSize ) ) ){\r
1904                 EPS_RETURN( ret )\r
1905         }\r
1906 \r
1907         /* check Request ID */\r
1908         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1909         if(nRqID != vField.val.v_long)\r
1910         {                               \r
1911                 if(EPS_ERR_NONE != ret )\r
1912                 {                                                                                       \r
1913                         EPS_RETURN( ret )\r
1914                 } \r
1915                 else if( ASN_VT_INTEGER != vField.type || \r
1916                         (nRqID != 0 && nRqID > vField.val.v_long ) )\r
1917                 {       \r
1918                         /* The data in front of one was received.->retry */\r
1919                         EPS_REREASE_VARIANT( vField );                                                          \r
1920                         EPS_RETURN( EPS_COM_READ_MORE )\r
1921                 }\r
1922         }\r
1923 \r
1924         /* check Error */\r
1925         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1926         SNMP_CHECK_INTVALUE( ret, vField, SNMP_ERR_NONE );\r
1927 \r
1928         /* skip Error Index */\r
1929         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1930         if(EPS_ERR_NONE != ret ){\r
1931                 EPS_RETURN( ret )       \r
1932         }\r
1933         /* skip Sequence Head */\r
1934         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1935         if(EPS_ERR_NONE != ret ){\r
1936                 EPS_RETURN( ret )       \r
1937         }\r
1938         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1939         if(EPS_ERR_NONE != ret ){\r
1940                 EPS_RETURN( ret )       \r
1941         }\r
1942 \r
1943         /* Get MIB ID */\r
1944         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1945         /*EPS_DBGPRINT(("\nORG : %s\nRES : %s\n", pObjID, vField.val.v_str))*/\r
1946 \r
1947         /* Check response MIB ID */\r
1948         pOrg = pObjID;\r
1949         pRes = vField.val.v_str;\r
1950     while(*pOrg != '\0' && *pRes != '\0'){\r
1951                 if( *pOrg++ < *pRes++ ){\r
1952                         /*if( strchr(pOrg, '.') != NULL){*/\r
1953                                 ret = EPS_COM_NEXT_RECORD;\r
1954                         /*}  else{ next item } */\r
1955                         break;\r
1956                 }\r
1957     }\r
1958         if( pResObjID ){\r
1959                 memset(pResObjID, 0, nResObjIDSize);\r
1960                 memcpy(pResObjID, vField.val.v_str, Min(nResObjIDSize-1, (EPS_INT32)strlen(vField.val.v_str)));\r
1961         }\r
1962         \r
1963         EPS_REREASE_VARIANT( vField );\r
1964         if( EPS_ERR_NONE != ret){\r
1965                 EPS_RETURN( ret )\r
1966         }\r
1967 \r
1968         /* get valiable */\r
1969         ret = ParseField( &pBuf, &nDataSize, &vField );\r
1970 \r
1971         *pPDU = vField;\r
1972 \r
1973         EPS_RETURN( ret )\r
1974 }\r
1975 \r
1976 \r
1977 /*******************************************|********************************************/\r
1978 /*                                                                                      */\r
1979 /* Function name:     ParseField()                                                      */\r
1980 /*                                                                                      */\r
1981 /* Arguments                                                                            */\r
1982 /* ---------                                                                            */\r
1983 /* Name:        Type:               Description:                                        */\r
1984 /* nSrc         EPS_INT8**          I/O: PDU buffer                                     */\r
1985 /* pDataSize    EPS_INT32*          I/O: PDU buffer size                                */\r
1986 /* pVal         ASN_VARIANT*        O: PDU field structure                              */\r
1987 /*                                                                                      */\r
1988 /* Return value:                                                                        */\r
1989 /*      EPS_ERR_NONE                                    - Success                                           */\r
1990 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
1991 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
1992 /*                                                                                      */\r
1993 /* Description:                                                                         */\r
1994 /*      Parse PDU field.  And move next area.                                           */\r
1995 /*                                                                                      */\r
1996 /*******************************************|********************************************/\r
1997 static EPS_ERR_CODE ParseField(\r
1998                                                            \r
1999                 EPS_INT8**      pSrc, \r
2000                 EPS_INT32*              pDataSize,\r
2001                 ASN_VARIANT*    pVal\r
2002                 \r
2003 ){\r
2004         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
2005         EPS_UINT32 nInt = 0;\r
2006 \r
2007         /* Field type */\r
2008         pVal->type = *((*pSrc)++);\r
2009         (*pDataSize)--;\r
2010         if(*pDataSize <= 0){            /* data size not enough */\r
2011                 return EPS_ERR_COMM_ERROR;\r
2012         }\r
2013 \r
2014         /* Field length */\r
2015         if( EPS_ERR_NONE != (ret = ParseLength( pSrc, pDataSize, &nInt ) ) ){\r
2016                 pVal->length = 0;\r
2017                 return ret;\r
2018         }\r
2019         pVal->length = nInt;\r
2020         if((EPS_UINT32)*pDataSize < pVal->length){              /* data size not enough */\r
2021                 return EPS_ERR_COMM_ERROR;\r
2022         }\r
2023 \r
2024         /* Field value */\r
2025         switch( pVal->type ){\r
2026         case ASN_VT_INTEGER:\r
2027                 pVal->val.v_long = BerToInt(*pSrc, pVal->length);\r
2028                 break;\r
2029 \r
2030         case ASN_VT_NULL:\r
2031                 pVal->val.v_long = 0;\r
2032                 break;\r
2033 \r
2034         case ASN_VT_OCTET_STRING:\r
2035                 pVal->val.v_str = *pSrc;\r
2036                 break;\r
2037 \r
2038         case ASN_VT_OBJECT_ID:\r
2039                 {\r
2040                         EPS_INT8* p = NULL;\r
2041                         ret = OidToStr( *pSrc, pVal->length, &p);\r
2042                         if( EPS_ERR_NONE != ret ){\r
2043                                 return ret;\r
2044                         }\r
2045                         pVal->val.v_str = p;\r
2046                 }\r
2047                 break;\r
2048 \r
2049         case ASN_VT_SEQUENCE:\r
2050                 pVal->val.v_str = *pSrc;\r
2051                 return ret;     /* Not move next */\r
2052                 break;\r
2053 \r
2054         }\r
2055 \r
2056         *pSrc += pVal->length;  /* Move next field */\r
2057         *pDataSize -= pVal->length;\r
2058 \r
2059         return ret;\r
2060 }\r
2061 \r
2062 \r
2063 /*******************************************|********************************************/\r
2064 /*                                                                                      */\r
2065 /* Function name:     MakeIntField()                                                    */\r
2066 /*                                                                                      */\r
2067 /* Arguments                                                                            */\r
2068 /* ---------                                                                            */\r
2069 /* Name:        Type:               Description:                                        */\r
2070 /* nSrc         EPS_INT32           I: int value                                        */\r
2071 /* pDst         EPS_INT8*           I: PDU buffer                                       */\r
2072 /*                                                                                      */\r
2073 /* Return value:                                                                        */\r
2074 /*      EPS_INT8*       : pointer for next area                                             */\r
2075 /*                                                                                      */\r
2076 /* Description:                                                                         */\r
2077 /*      Make BER integer field.  And move next area.                                    */\r
2078 /*                                                                                      */\r
2079 /*******************************************|********************************************/\r
2080 static EPS_INT8* MakeIntField(\r
2081                                                           \r
2082                 EPS_INT32 nSrc, \r
2083                 EPS_INT8* pDst\r
2084                 \r
2085 ){\r
2086         EPS_INT16       nLen = 0;\r
2087 \r
2088         /* Field type */\r
2089         *(pDst++) = ASN_VT_INTEGER;\r
2090 \r
2091         /* Field value */\r
2092         nLen = IntToBer(nSrc, pDst);\r
2093         memmove(pDst+nLen, pDst , nLen);\r
2094 \r
2095         /* Field length */\r
2096         pDst = MakeLength( nLen, pDst );\r
2097         pDst += nLen;\r
2098 \r
2099         return pDst;\r
2100 }\r
2101 \r
2102 \r
2103 /*******************************************|********************************************/\r
2104 /*                                                                                      */\r
2105 /* Function name:     MakeStrField()                                                    */\r
2106 /*                                                                                      */\r
2107 /* Arguments                                                                            */\r
2108 /* ---------                                                                            */\r
2109 /* Name:        Type:               Description:                                        */\r
2110 /* pSrc         EPS_INT8*           I: string                                           */\r
2111 /* pDst         EPS_INT8*           I: PDU buffer                                       */\r
2112 /*                                                                                      */\r
2113 /* Return value:                                                                        */\r
2114 /*      EPS_INT8*       : pointer for next area                                             */\r
2115 /*                                                                                      */\r
2116 /* Description:                                                                         */\r
2117 /*      Make BER string field.  And move next area.                                     */\r
2118 /*                                                                                      */\r
2119 /*******************************************|********************************************/\r
2120 static EPS_INT8* MakeStrField(\r
2121                                                           \r
2122                 const EPS_INT8* pSrc, \r
2123                 EPS_INT8*       pDst\r
2124                 \r
2125 ){\r
2126         EPS_UINT32      nLen = (EPS_UINT32)strlen(pSrc);\r
2127 \r
2128         /* Field type */\r
2129         *(pDst++) = ASN_VT_OCTET_STRING;\r
2130 \r
2131         /* Field length */\r
2132         pDst = MakeLength( nLen, pDst );\r
2133 \r
2134         /* Field value */\r
2135         memcpy(pDst, pSrc, nLen);\r
2136 \r
2137         pDst += nLen;\r
2138 \r
2139         return pDst;\r
2140 }\r
2141 \r
2142 \r
2143 /*******************************************|********************************************/\r
2144 /*                                                                                      */\r
2145 /* Function name:     MakeOidField()                                                    */\r
2146 /*                                                                                      */\r
2147 /* Arguments                                                                            */\r
2148 /* ---------                                                                            */\r
2149 /* Name:        Type:               Description:                                        */\r
2150 /* pSrc         EPS_INT8*           I: ObjectID string                                  */\r
2151 /* pDst         EPS_INT8**          I/O: PDU buffer(point to length field)              */\r
2152 /*                                                                                      */\r
2153 /* Return value:                                                                        */\r
2154 /*      EPS_ERR_NONE                                    - Success                                           */\r
2155 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2156 /*                                                                                      */\r
2157 /* Description:                                                                         */\r
2158 /*      Make BER ObjectID field.  And move next area.                                   */\r
2159 /*                                                                                      */\r
2160 /*******************************************|********************************************/\r
2161 static EPS_ERR_CODE MakeOidField(\r
2162                                                                  \r
2163                 const EPS_INT8* pSrc, \r
2164                 EPS_INT8**      pDst\r
2165                 \r
2166 ){\r
2167         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
2168         EPS_INT8        cOid[SNMP_MAX_OID];\r
2169         EPS_UINT16      nLen = 0;\r
2170 \r
2171         /* Field type */\r
2172         *(*pDst)++ = ASN_VT_OBJECT_ID;\r
2173 \r
2174         /* Create OID */\r
2175         nLen = sizeof(cOid);\r
2176         if( EPS_ERR_NONE != (ret = StrToOid(pSrc, cOid, &nLen)) ){\r
2177                 return ret;\r
2178         }\r
2179 \r
2180         /* Field length */\r
2181         *pDst = MakeLength( nLen, *pDst );\r
2182 \r
2183         /* Field value */\r
2184         memcpy(*pDst, cOid, nLen);\r
2185 \r
2186         *pDst += nLen;\r
2187 \r
2188         return ret;\r
2189 }\r
2190 \r
2191 \r
2192 /*******************************************|********************************************/\r
2193 /*                                                                                      */\r
2194 /* Function name:     MakeSequens()                                                     */\r
2195 /*                                                                                      */\r
2196 /* Arguments                                                                            */\r
2197 /* ---------                                                                            */\r
2198 /* Name:        Type:               Description:                                        */\r
2199 /* pSrc         EPS_INT8*           I: PDU buffer(point to length field)                */\r
2200 /* pSize        EPS_UINT32*         O: pointer for length                               */\r
2201 /* bNeedType    EPS_BOOL            I: pointer for length                               */\r
2202 /*                                                                                      */\r
2203 /* Return value:                                                                        */\r
2204 /*      EPS_ERR_NONE                                    - Success                                           */\r
2205 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2206 /*                                                                                      */\r
2207 /* Description:                                                                         */\r
2208 /*      Make BER Sequens. And move next area.                                           */\r
2209 /*                                                                                      */\r
2210 /*******************************************|********************************************/\r
2211 static EPS_ERR_CODE MakeSequens(\r
2212                                                                 \r
2213                 EPS_INT8*   pSrc, \r
2214                 EPS_UINT32* pSize, \r
2215                 EPS_BOOL    bNeedType\r
2216 \r
2217 ){\r
2218         EPS_ERR_CODE ret = EPS_ERR_NONE;\r
2219         EPS_INT8        nLengthLen = 0;\r
2220 \r
2221         /* Length field length calculation */\r
2222         if(*pSize <= 0x7F){\r
2223                 nLengthLen = 1;\r
2224         } else{\r
2225                 if( EPS_ENDIAN_LITTLE == cpuEndian ){\r
2226                         nLengthLen = (sizeof(EPS_INT32) / sizeof(EPS_INT8)) - 1;\r
2227                         for(; nLengthLen > -1 && 0x00 == *((EPS_UINT8*)pSize + nLengthLen); nLengthLen--);\r
2228                 } else{ \r
2229                         EPS_INT8 nLim = sizeof(EPS_INT32) / sizeof(EPS_INT8);\r
2230                         for(; nLengthLen < nLim && 0x00 == *((EPS_INT8*)pSize + nLengthLen); nLengthLen++);\r
2231                 }\r
2232         }\r
2233 \r
2234         if( bNeedType ){\r
2235                 memmove(pSrc + nLengthLen + 1, pSrc, *pSize);   /* 1 = Field type */\r
2236 \r
2237                 /* Field type */\r
2238                 *(pSrc++) = ASN_VT_SEQUENCE;\r
2239 \r
2240                 /* Field length */\r
2241                 pSrc = MakeLength( *pSize, pSrc );\r
2242 \r
2243                 *pSize += nLengthLen + 1;\r
2244         } else{\r
2245                 memmove(pSrc + nLengthLen, pSrc, *pSize);\r
2246 \r
2247                 /* Field length */\r
2248                 pSrc = MakeLength( *pSize, pSrc );\r
2249 \r
2250                 *pSize += nLengthLen;\r
2251         }\r
2252 \r
2253         return ret;\r
2254 }\r
2255 \r
2256 \r
2257 /*******************************************|********************************************/\r
2258 /*                                                                                      */\r
2259 /* Function name:     ParseLength()                                                     */\r
2260 /*                                                                                      */\r
2261 /* Arguments                                                                            */\r
2262 /* ---------                                                                            */\r
2263 /* Name:        Type:               Description:                                        */\r
2264 /* pSrc         EPS_INT8**          I/O: PDU buffer(point to length field)              */\r
2265 /* pLength      EPS_UINT32*         O: pointer for length                               */\r
2266 /*                                                                                      */\r
2267 /* Return value:                                                                        */\r
2268 /*      EPS_ERR_NONE                                    - Success                                           */\r
2269 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2270 /*      EPS_ERR_COMM_ERROR              - Communication Error                           */\r
2271 /*                                                                                      */\r
2272 /* Description:                                                                         */\r
2273 /*      Parse Length field.  And move next area.                                        */\r
2274 /*                                                                                      */\r
2275 /*******************************************|********************************************/\r
2276 static EPS_ERR_CODE ParseLength(\r
2277                                                                 \r
2278                 EPS_INT8**  pSrc, \r
2279                 EPS_INT32*  pDataSize,\r
2280                 EPS_UINT32* pLength\r
2281                 \r
2282 ){\r
2283         *pLength = 0;\r
2284 \r
2285         if( (**pSrc) & 0x80 ){\r
2286                 EPS_INT8 n = 0;\r
2287                 EPS_INT8 nLenLength = (**pSrc) ^ 0x80;\r
2288                 if(sizeof(EPS_UINT32) < (EPS_UINT8)nLenLength){\r
2289                         /* Over flow */\r
2290                         return EPS_ERR_MEMORY_ALLOCATION;\r
2291                 }\r
2292 \r
2293                 (*pSrc)++;      (*pDataSize)--;\r
2294 \r
2295                 if( EPS_ENDIAN_LITTLE == cpuEndian ){\r
2296                         for(n = nLenLength-1; n >= 0; n--){\r
2297                                 *((EPS_INT8*)&(*pLength) + n) = *(*pSrc)++;     \r
2298                                 (*pDataSize)--;\r
2299                         }\r
2300                 } else{\r
2301                         for(n = sizeof(EPS_UINT32) - nLenLength; (EPS_UINT8)n < sizeof(EPS_UINT32); n++){\r
2302                                 *((EPS_INT8*)&(*pLength) + n) = *(*pSrc)++;\r
2303                                 (*pDataSize)--;\r
2304                                 if(*pDataSize <= 0){    /* data size not enough */\r
2305                                         return EPS_ERR_COMM_ERROR;\r
2306                                 }\r
2307                         }\r
2308                 }\r
2309         } else{\r
2310                 *pLength = *(*pSrc)++;\r
2311                 (*pDataSize)--;\r
2312         }\r
2313 \r
2314         if((EPS_UINT32)*pDataSize < *pLength){  /* data size not enough */\r
2315                 return EPS_ERR_COMM_ERROR;\r
2316         }\r
2317 \r
2318         return EPS_ERR_NONE;\r
2319 }\r
2320 \r
2321 \r
2322 /*******************************************|********************************************/\r
2323 /*                                                                                      */\r
2324 /* Function name:     MakeLength()                                                      */\r
2325 /*                                                                                      */\r
2326 /* Arguments                                                                            */\r
2327 /* ---------                                                                            */\r
2328 /* Name:        Type:               Description:                                        */\r
2329 /* nLength          EPS_INT32           I: length value                                     */\r
2330 /* pDst         EPS_INT8*           O: length field                                     */\r
2331 /*                                                                                      */\r
2332 /* Return value:                                                                        */\r
2333 /*      EPS_INT8*       : pointer for next area                                             */\r
2334 /*                                                                                      */\r
2335 /* Description:                                                                         */\r
2336 /*      Make BER length field.  And move next area.                                     */\r
2337 /*                                                                                      */\r
2338 /*******************************************|********************************************/\r
2339 static EPS_INT8* MakeLength(\r
2340                                                         \r
2341                 EPS_INT32 nLength, \r
2342                 EPS_INT8* pDst\r
2343 \r
2344 ){\r
2345         if(nLength <= 0x7F){\r
2346                 *(pDst++) = (EPS_INT8)nLength;\r
2347         } else{\r
2348 \r
2349                 if( EPS_ENDIAN_LITTLE == cpuEndian ){\r
2350                         EPS_INT8        n = (sizeof(EPS_INT32) / sizeof(EPS_INT8)) - 1;\r
2351 \r
2352                         /* set length */\r
2353                         for(; n > -1 && 0x00 == *((EPS_INT8*)&nLength + n); n--);\r
2354                         *(pDst++) = (EPS_INT8)(0x80 & (n+1));\r
2355 \r
2356                         for(; n > -1; n--){\r
2357                                 *(pDst++) = *((EPS_INT8*)&nLength + n);\r
2358                         }\r
2359                 } else{\r
2360                         EPS_INT8 nLim = sizeof(EPS_INT32) / sizeof(EPS_INT8);\r
2361                         EPS_INT8 n = 0;\r
2362 \r
2363                         /* set length */\r
2364                         for(; n < nLim && 0x00 == *((EPS_INT8*)&nLength + n); n++);\r
2365                         *(pDst++) = (EPS_INT8)(0x80 & (nLim-n));\r
2366 \r
2367                         for(; n < nLim; n++){\r
2368                                 *(pDst++) = *((EPS_INT8*)&nLength + n);\r
2369                         }\r
2370                 }       \r
2371         }\r
2372 \r
2373         return pDst;\r
2374 }\r
2375 \r
2376 \r
2377 /*******************************************|********************************************/\r
2378 /*                                                                                      */\r
2379 /* Function name:     OidToStr()                                                        */\r
2380 /*                                                                                      */\r
2381 /* Arguments                                                                            */\r
2382 /* ---------                                                                            */\r
2383 /* Name:        Type:               Description:                                        */\r
2384 /* nSrc         EPS_INT8*           I: ObjectID binary                                  */\r
2385 /* nSrcLen      EPS_UINT16          O: ObjectID binary length                           */\r
2386 /* pDst         EPS_INT8**          O: ObjectID string                                  */\r
2387 /*                                                                                      */\r
2388 /* Return value:                                                                        */\r
2389 /*      EPS_ERR_NONE                                    - Success                                           */\r
2390 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2391 /*                                                                                      */\r
2392 /* Description:                                                                         */\r
2393 /*      Convert binary MIB ObjectID to string.                                          */\r
2394 /*                                                                                      */\r
2395 /*******************************************|********************************************/\r
2396 static EPS_ERR_CODE OidToStr(\r
2397                                                          \r
2398                 EPS_INT8*   pSrc, \r
2399                 EPS_UINT32  nSrcLen, \r
2400                 EPS_INT8**  pDst\r
2401 ){\r
2402 \r
2403 #define SNMP_OID_SIZE_INI       (32)\r
2404 #define SNMP_OID_SIZE_GRW       (16)    /* 32bit max = 4294967295 is 10 character */\r
2405         EPS_UINT16      nCnt = 0;\r
2406         EPS_UINT16      nDstSize = 0;\r
2407         EPS_UINT16      nDstLen = 0;\r
2408         EPS_INT8*       pTmp = NULL;\r
2409         EPS_UINT32      nElm = 0;\r
2410         EPS_INT8*       pEnd = pSrc + nSrcLen;\r
2411 \r
2412         nDstSize = SNMP_OID_SIZE_INI;\r
2413         *pDst = (EPS_INT8*)EPS_ALLOC( nDstSize );\r
2414 \r
2415         sprintf(*pDst, "%d.%d.", *pSrc / 40, *pSrc % 40);\r
2416         pSrc++;\r
2417 \r
2418         while( pSrc < pEnd ){\r
2419                 nDstLen = (EPS_UINT16)strlen(*pDst);\r
2420                 if( nDstSize - nDstLen < SNMP_OID_SIZE_GRW ){\r
2421                         nDstSize += SNMP_OID_SIZE_GRW;\r
2422                         pTmp = (EPS_INT8*)EPS_ALLOC( nDstSize );\r
2423                         if(pTmp){\r
2424                                 memcpy(pTmp, *pDst, nDstLen+1);\r
2425                                 EPS_SAFE_RELEASE( *pDst );\r
2426                                 *pDst = pTmp;\r
2427                         } else{\r
2428                                 EPS_SAFE_RELEASE( *pDst );\r
2429                                 return EPS_ERR_MEMORY_ALLOCATION;\r
2430                         }\r
2431                 }\r
2432 \r
2433                 if( 0x80 & *pSrc ){\r
2434                         nElm = 0;\r
2435                         while( 0x80 & pSrc[nCnt] ){\r
2436                                 nElm += (EPS_INT8)( *(pSrc++) ^ 0x80 );\r
2437                                 nElm <<= 7;\r
2438                         }\r
2439                         nElm += (EPS_INT8)(*(pSrc++));\r
2440 \r
2441                         sprintf(&(*pDst)[nDstLen], "%d.", nElm);\r
2442                 } else{\r
2443                         sprintf(&(*pDst)[nDstLen], "%d.", *(pSrc++)); \r
2444                 }\r
2445         }\r
2446 \r
2447         nDstLen = (EPS_UINT16)strlen(*pDst) - 1;\r
2448         (*pDst)[nDstLen] = '\0';\r
2449 \r
2450         return EPS_ERR_NONE;\r
2451 }       \r
2452 \r
2453 \r
2454 /*******************************************|********************************************/\r
2455 /*                                                                                      */\r
2456 /* Function name:     StrToOid()                                                        */\r
2457 /*                                                                                      */\r
2458 /* Arguments                                                                            */\r
2459 /* ---------                                                                            */\r
2460 /* Name:        Type:               Description:                                        */\r
2461 /* nSrc             EPS_INT8*           I: ObjectID string                                  */\r
2462 /* pDst             EPS_INT8*           O: ObjectID binary                                  */\r
2463 /* pDstLen      EPS_INT16*          I/O: ObjectID binary length                         */\r
2464 /*                                                                                      */\r
2465 /* Return value:                                                                        */\r
2466 /*      EPS_ERR_NONE                                    - Success                                           */\r
2467 /*      EPS_ERR_MEMORY_ALLOCATION       - Failed to allocate memory                     */\r
2468 /*                                                                                      */\r
2469 /* Description:                                                                         */\r
2470 /*      Convert string to MIB ObjectID binary.                                          */\r
2471 /*                                                                                      */\r
2472 /*******************************************|********************************************/\r
2473 static EPS_ERR_CODE StrToOid(\r
2474                                                          \r
2475                 const EPS_INT8* pSrc, \r
2476                 EPS_INT8*       pDst, \r
2477                 EPS_UINT16*     pDstLen\r
2478                 \r
2479 ){\r
2480         EPS_UINT16      nCnt = 0;\r
2481         EPS_INT8*       pTmp = NULL;\r
2482         EPS_INT8*       p = NULL;\r
2483         EPS_UINT32      nElm = 0;\r
2484         EPS_UINT8       nBinNum = 0;\r
2485         EPS_UINT8       n = 0;\r
2486 \r
2487         pTmp = (EPS_INT8*)EPS_ALLOC( strlen(pSrc)+1 );\r
2488         if(!pTmp){\r
2489                 return EPS_ERR_MEMORY_ALLOCATION;\r
2490         }\r
2491         strcpy(pTmp, pSrc);\r
2492 \r
2493         p = strtok(pTmp, ".");\r
2494         if( NULL != p ){\r
2495                 pDst[nCnt] = (EPS_INT8)(atoi(p) * 40);\r
2496         } else{\r
2497                 EPS_FREE(pTmp);\r
2498                 return EPS_ERR_NONE;\r
2499         }\r
2500         p = strtok(NULL, ".");\r
2501         if( NULL != p ){\r
2502                 pDst[nCnt] += (EPS_INT8)(atoi(p));\r
2503                 nCnt++;\r
2504         } else{\r
2505                 EPS_FREE(pTmp);\r
2506                 return EPS_ERR_NONE;\r
2507         }\r
2508 \r
2509         p = strtok(NULL, ".");\r
2510         while( NULL != p){\r
2511                 if(*pDstLen-1 < nCnt){\r
2512                         return EPS_ERR_MEMORY_ALLOCATION;\r
2513                 }\r
2514 \r
2515                 nElm = atoi(p);\r
2516                 if(0x7f >= nElm){\r
2517                         pDst[nCnt] = (EPS_INT8)nElm;\r
2518                 } else{\r
2519                         /* Necessary byte number calculation */\r
2520                         for(nBinNum = 0; !((nElm << nBinNum) & 0x80000000); nBinNum++);\r
2521 \r
2522                         nBinNum = sizeof(EPS_UINT32)*8 - nBinNum;\r
2523                         nBinNum = nBinNum / 7 + ((nBinNum%7)?1:0);\r
2524                         nCnt += nBinNum-1;\r
2525 \r
2526                         /* It stores it by dividing 7 bits. */\r
2527                         pDst[nCnt] = (EPS_INT8)(nElm & 0x7F);\r
2528                         for(n = 1; n < nBinNum; n++){\r
2529                                 pDst[nCnt-n] = (EPS_INT8)(((nElm >> 7*n) & 0x7F) + 0x80);\r
2530                         }\r
2531                 }\r
2532 \r
2533                 nCnt++;\r
2534                 p = strtok(NULL, ".");\r
2535         }\r
2536 \r
2537         EPS_SAFE_RELEASE(pTmp);\r
2538         *pDstLen = nCnt;\r
2539 \r
2540         return EPS_ERR_NONE;\r
2541 }       \r
2542 \r
2543 \r
2544 /*******************************************|********************************************/\r
2545 /*                                                                                      */\r
2546 /* Function name:     IntToBer()                                                        */\r
2547 /*                                                                                      */\r
2548 /* Arguments                                                                            */\r
2549 /* ---------                                                                            */\r
2550 /* Name:        Type:               Description:                                        */\r
2551 /* nSrc             EPS_INT32           I: int value                                        */\r
2552 /* pDst             EPS_INT32           O: pointer for BER Integer                          */\r
2553 /*                                                                                      */\r
2554 /* Return value:                                                                        */\r
2555 /*      EPS_INT16       : BER Integer length                                                */\r
2556 /*                                                                                      */\r
2557 /* Description:                                                                         */\r
2558 /*      Convert integer to BER integer.                                                 */\r
2559 /*                                                                                      */\r
2560 /*******************************************|********************************************/\r
2561 static EPS_UINT16 IntToBer(\r
2562 \r
2563                 EPS_INT32 nSrc, \r
2564                 EPS_INT8* pDst\r
2565 \r
2566 ){\r
2567         EPS_UINT16      nCnt = 0;\r
2568 \r
2569         if( EPS_ENDIAN_LITTLE == cpuEndian ){\r
2570                 EPS_INT8        n = (sizeof(EPS_INT32) / sizeof(EPS_INT8)) - 1;\r
2571 \r
2572                 for(; n > -1; n--){\r
2573                         if( 0 == nCnt){\r
2574                                 /* An unnecessary bit is thrown away. */\r
2575                                 if( 0xff == (EPS_INT32)*((EPS_UINT8*)&nSrc + n) ){\r
2576                                         if( n > 0 &&\r
2577                                                 *((EPS_UINT8*)&nSrc + n-1) & 0x80 ){\r
2578                                                 continue;\r
2579                                         }\r
2580                                 } else if( 0x00 == *((EPS_UINT8*)&nSrc + n) ){\r
2581                                         if( n > 0 &&\r
2582                                                 !(*((EPS_UINT8*)&nSrc + n-1) & 0x80) ){\r
2583                                                 continue;\r
2584                                         }\r
2585                                 }\r
2586                         }\r
2587 \r
2588                         *(pDst++) = *((EPS_UINT8*)&nSrc + n);\r
2589                         nCnt++;\r
2590                 }\r
2591         } else{\r
2592                 EPS_INT8        nMax = (sizeof(EPS_INT32) / sizeof(EPS_INT8));\r
2593                 EPS_INT8        n = 0;\r
2594 \r
2595                 for(; n < nMax; n++){\r
2596                         if( 0 == nCnt){\r
2597                                 /* An unnecessary bit is thrown away. */\r
2598                                 if( 0xff == *((EPS_UINT8*)&nSrc + n) ){\r
2599                                         if( n < nMax-1 &&\r
2600                                                 *((EPS_UINT8*)&nSrc + n+1) & 0x80 ){\r
2601                                                 continue;\r
2602                                         }\r
2603                                 } else if( 0x00 == *((EPS_UINT8*)&nSrc + n) ){\r
2604                                         if( n < nMax-1 &&\r
2605                                                 !(*((EPS_UINT8*)&nSrc + n+1) & 0x80) ){\r
2606                                                 continue;\r
2607                                         }\r
2608                                 }\r
2609                         }\r
2610 \r
2611                         *(pDst++) = *((EPS_UINT8*)&nSrc + n);\r
2612                         nCnt++;\r
2613                 }\r
2614         }\r
2615 \r
2616         return nCnt;\r
2617 }       \r
2618 \r
2619 \r
2620 /*******************************************|********************************************/\r
2621 /*                                                                                      */\r
2622 /* Function name:     BerToInt()                                                        */\r
2623 /*                                                                                      */\r
2624 /* Arguments                                                                            */\r
2625 /* ---------                                                                            */\r
2626 /* Name:        Type:               Description:                                        */\r
2627 /* nSrc             EPS_INT32           I: pointer for BER Integer                          */\r
2628 /* pDst             EPS_INT32           I: BER Integer length                               */\r
2629 /*                                                                                      */\r
2630 /* Return value:                                                                        */\r
2631 /*      EPS_INT32       : int value                                                         */\r
2632 /*                                                                                      */\r
2633 /* Description:                                                                         */\r
2634 /*      Convert BER integer to integer.                                                 */\r
2635 /*                                                                                      */\r
2636 /*******************************************|********************************************/\r
2637 static EPS_INT32 BerToInt(\r
2638 \r
2639                 EPS_INT8* pSrc, \r
2640                 EPS_INT32 nLen\r
2641 \r
2642 ){\r
2643         EPS_INT32       nDst = 0;\r
2644 \r
2645         if( EPS_ENDIAN_LITTLE == cpuEndian ){\r
2646                 EPS_INT8        nMax = (sizeof(EPS_INT32) / sizeof(EPS_INT8)) - 1;\r
2647                 EPS_INT32       n = 0;\r
2648                 EPS_INT32       m = nLen - 1;\r
2649 \r
2650                 for(; n < nMax && m > -1; n++, m--){\r
2651                         *((EPS_INT8*)&nDst + n) = *(pSrc+m);\r
2652                 }\r
2653 \r
2654                 if( n < nMax ){\r
2655                         if( *(pSrc) & 0x80 ){\r
2656                                 memset(((EPS_INT8*)&nDst + n), 0xff, nMax-(n-1));\r
2657                         } else{\r
2658                                 memset(((EPS_INT8*)&nDst + n), 0x00, nMax-(n-1));\r
2659                         }\r
2660                 }\r
2661         } else{\r
2662                 EPS_INT8        nDstSize = (sizeof(EPS_INT32) / sizeof(EPS_INT8));\r
2663                 EPS_INT32       n = nDstSize-nLen;\r
2664                 EPS_INT32       m = 0;\r
2665 \r
2666                 if( *(pSrc) & 0x80 ){\r
2667                         memset(&nDst, 0xff, nDstSize-nLen);\r
2668                 } else{\r
2669                         memset(&nDst, 0x00, nDstSize-nLen);\r
2670                 }\r
2671 \r
2672                 for(; n < nDstSize && m < nLen; n++, m++){\r
2673                         *((EPS_INT8*)&nDst + n) = *(pSrc+m);\r
2674                 }\r
2675         }\r
2676 \r
2677         return nDst;\r
2678 }       \r
2679 \r
2680 \r
2681 /*******************************************|********************************************/\r
2682 /*                                                                                      */\r
2683 /* Function name:     GetRequestId()                                                                                            */\r
2684 /*                                                                                      */\r
2685 /* Arguments                                                                            */\r
2686 /* ---------                                                                            */\r
2687 /* (none)                                                                                                                       */\r
2688 /*                                                                                      */\r
2689 /* Return value:                                                                        */\r
2690 /*      EPS_INT16       : RequestID                                                                                             */\r
2691 /*                                                                                      */\r
2692 /* Description:                                                                         */\r
2693 /*      Generate SNMP request ID (value is between from 1 to 127).                      */\r
2694 /*                                                                                      */\r
2695 /*******************************************|********************************************/\r
2696 static EPS_UINT8 GetRequestId(void)\r
2697 {\r
2698         static EPS_UINT8 nId = 1;\r
2699 \r
2700         nId++;          \r
2701         if( (char)0x7f < nId ){\r
2702                 nId = 1;\r
2703         }\r
2704 \r
2705         return nId;\r
2706 }\r
2707 \r
2708 #ifdef GCOMSW_CMD_ESCPAGE\r
2709 static EPS_INT32 GetColorID(EPS_INT8* name)\r
2710 {\r
2711         EPS_INT32 id = EPS_COLOR_UNKNOWN;\r
2712         EPS_INT8* p;\r
2713 \r
2714         if( memStrStr(name, "Black", FALSE) ){\r
2715                 id = EPS_COLOR_BLACK;\r
2716         } else if( memStrStr(name, "Cyan", FALSE) ){\r
2717             id = EPS_COLOR_CYAN;\r
2718         } else if( memStrStr(name, "Magenta", FALSE) ){\r
2719                 id = EPS_COLOR_MAGENTA;\r
2720         } else if( memStrStr(name, "Yellow", FALSE) ){\r
2721                 id = EPS_COLOR_YELLOW;\r
2722         } else if( memStrStr(name, "Red", FALSE) ){\r
2723                 id = EPS_COLOR_RED;\r
2724         } else if( memStrStr(name, "Violet", FALSE) ){\r
2725                 id = EPS_COLOR_VIOLET;\r
2726         } else if( memStrStr(name, "Clear", FALSE) ){\r
2727                 id = EPS_COLOR_CLEAR;\r
2728         } else if( memStrStr(name, "Gray", FALSE) ){\r
2729                 id = EPS_COLOR_GRAY;\r
2730         } else if( memStrStr(name, "Orange", FALSE) ){\r
2731                 id = EPS_COLOR_ORANGE;\r
2732         } else if( memStrStr(name, "Green", FALSE) ){\r
2733                 id = EPS_COLOR_GREEN;\r
2734         }\r
2735 \r
2736         if( (p = memStrStr(name, "Light", TRUE)) != NULL ){\r
2737                 if(EPS_COLOR_CYAN == id){\r
2738                         id = EPS_COLOR_LIGHTCYAN;\r
2739                 } else if(EPS_COLOR_MAGENTA == id){\r
2740                         id = EPS_COLOR_LIGHTMAGENTA;\r
2741                 } else if(EPS_COLOR_YELLOW == id){\r
2742                         id = EPS_COLOR_LIGHTYELLOW;\r
2743                 } else if(EPS_COLOR_BLACK == id){\r
2744                         if( memStrStr(p, "Light", FALSE) ){\r
2745                                 id = EPS_COLOR_LIGHTLIGHTBLACK;\r
2746                         } else{\r
2747                                 id = EPS_COLOR_LIGHTBLACK;\r
2748                         } \r
2749                 } \r
2750 \r
2751         } else if( memStrStr(name, "Matte", FALSE) ){\r
2752                 if(EPS_COLOR_BLACK == id){\r
2753                         id = EPS_COLOR_MATTEBLACK;\r
2754                 }\r
2755         } else if( memStrStr(name, "Dark", FALSE) ){\r
2756                 if(EPS_COLOR_YELLOW == id){\r
2757                         id = EPS_COLOR_DARKYELLOW;\r
2758                 }\r
2759         } else if( memStrStr(name, "Photo", FALSE) ){\r
2760                 if(EPS_COLOR_BLACK == id){\r
2761                         id = EPS_COLOR_PHOTOBLACK;\r
2762                 }\r
2763         }\r
2764 \r
2765         return id;\r
2766 }\r
2767 #endif /* GCOMSW_CMD_ESCPAGE */\r
2768 \r
2769 /*________________________________   epson-net-snmp.c   ________________________________*/\r
2770 \r
2771 /*34567890123456789012345678901234567890123456789012345678901234567890123456789012345678*/\r
2772 /*       1         2         3         4         5         6         7         8        */\r
2773 /*******************************************|********************************************/\r
2774 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r
2775 /***** End of File *** End of File *** End of File *** End of File *** End of File ******/\r
2776 /*%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%|%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%*/\r