KR20010090254A - Method for simple network management protocol communication using application programming interface - Google Patents

Abstract

PURPOSE: A simple network management protocol(SNMP) communication method using application programming interface(API) is provided to allow program calling to be easily carried out through SNMP API which is called by a message handler and generate SNMP packet by using the SNMP tool function. CONSTITUTION: A method comprises a first step(S10) of allowing each message handler to call SNMP API which is an API function of a control command for controlling an SNMP agent; a second step(S20) of allowing the SNMP API to call the SNMP tool and generate a packet; a third step(S30) of allowing the SNMP API to transmit the generated packet to the SNMP agent through an UDP socket; and a fourth step(S40) of checking an error of the data responding to the transmission, returning names and values of all objects contained in the responding data to the message handler if no error is found in the result of checking, and returning the predefined error code indicating reason of failure to the message handler if any error is found in the result of checking.

Description

METHOD FOR SIMPLE NETWORK MANAGEMENT PROTOCOL COMMUNICATION USING APPLICATION PROGRAMMING INTERFACE}

The present invention relates to a Simple Network Management Protocol (SNMP) interface, and more particularly, to a method for performing Simple Network Management Protocol (SNMP) communication using an application programming interface (API) function. .

As is generally known, the Simple Network Management Protocol (SNMP) is a network management protocol in a Transmission Control Protocol / Internet Protocol (TCP / IP) environment. An SNMP agent is used for devices (network elements) requiring continuous management, such as hubs. By installing the software, the remote manager can monitor the operation status of each port.

SNMP is a connection-less service, which uses a control command PDU (Product Data Unit), which is transmitted through an authentication service. This transmission unit is called a message, and the message is transmitted using UDP (User Datagram Protocol).

SNMP basically manages the network using five control commands (PDUs): GetRequest, GetNextRequest, SetRequest, GetResponse, and Trap.

The GetRequest is a control command for the manager to get the value of a specific Managed Object (MO) in the delegate, and the GetNextRequest is the next object value of the object value specified by the manager or the next index value if the object is a table. Control command to come. GetResponse is a control command for the agent to return the object value at the request of the administrator. SetRequest is a control command for the manager to change the value of the object in the agent. Trap is a control command for the agent to inform the manager that a specific fault condition has occurred or to send a response when the response time for a request is long.

In 1997 Epilogue Technology Co. released the Epilogue Tool to implement SNMP. This epilogue tool provides various functions for SNMP communication. As described above, the conventional SNMP protocol using the epilogue tool directly calls a low-level function provided by the SNMP tool (eplog) to implement a communication interface between an administrator and an agent.

Referring to FIG. 1 illustrating the operation of SNMP according to the prior art, the message handler 120 and 130 in the SNMP manager 110 may generate a packet using the epilogue tool 140 and generate a UDP socket ( The packet is transmitted to the SNMP agent 150 in the network element (NE) 150 through the socket and receives the response.

As described above, a communication program (ie, a message handler) according to the prior art which wants to communicate with a network element using SNMP has various functions (GetConf) according to the purpose and type of information inquiry (Get) and value set (Set). , SetConf, GetV52, SetV52, etc.) were used in combination, and the packet generated using this function was directly exchanged with the network device through the UDP socket.

Therefore, since the prior art does not use predefined internal functions, when writing a communication program using an SNMP interface, many message handlers have to repeat function combinations and code generation for programming each time. You had to understand the structure of the tool.

In addition, when writing and using low-level SNMP code, programmers have different methods of writing functions. Therefore, when using SNMP code written by other programmers, there was a problem that it took much time to debug and measure performance.

Accordingly, an object of the present invention, which was devised to solve the problems of the prior art operating as described above, provides an SNMP API function that is called by a message handler to generate and process an SNMP packet, and codes and errors of an SNMP interface program. It is to provide SNMP communication method using API that standardizes code to API and facilitates coding and debugging.

An embodiment of the SNMP communication method using the API according to the present invention, which was created to achieve the object as described above, is characterized in that a plurality of message handlers in a simple network management protocol (SNMP) manager use an epilogue tool to generate an SNMP agent of a network element. In the method for managing,

A first step in which each message handler calls an SNMP API, which is an application programming interface (API) function of a control command (PDU) for managing the SNMP agent;

The invoked SNMP API includes a second step of performing a control command for managing an SNMP agent using the epilogue tool and returning the result to the message handler.

1 is a software block diagram illustrating SNMP communication in the prior art.

2 is a software block diagram illustrating SNMP API communication in accordance with the present invention.

3 is a flow diagram illustrating SNMP API communication in accordance with the present invention.

Hereinafter, the operation principle of SNMP communication according to the present invention will be described in detail with reference to the accompanying drawings.

2 is a software block diagram illustrating the operation of SNMP communication according to the present invention, and FIG. 3 is a flowchart illustrating the operation of SNMP communication according to the present invention.

2 and 3 according to the present invention, the message handler is called by the message handlers 220 and 230 of the SNMP manager 210, instead of directly using the epilog tool. Characterized by providing an SNMP API 240 for generating an SNMP packet using (250). That is, each message handler 220, 230 communicates with the SNMP agent 260 of the network element (NE) 260 by calling the SNMP API 240.

The above API is an abstract concept that provides easy access to an OS (Operating System) service or protocol, and is a kind of library that collects various functions used internally. Application programs typically use APIs to request low-level services of the operating system, such as data communications, data recovery, and system resource access. Accordingly, the present invention provides the API function of the control command for network management as the SNMP API (240).

When the message handler 220 and 230 in the SNMP manager 210 calls the SNMP API 240 in step S10 of FIG. 3, the SNMP API 240 calls the epilog tool 250 in step S20. To generate the packet. In step s30, the SNMP API 240 transmits the generated packet to the SNMP agent 260 through the UDP socket, and receives the response in step s40 to return the processing result to the message handler 220 or 230. Return.

In order to enable the message handlers 220 and 230 to communicate with the network element NE using the SNMP API 240, the SNMP API 240 according to the present invention uses five kinds of control commands, namely, GetRequest, Provides GetNextRequest, SetRequest, SendTrapRequest, and TrapAnalyzer API functions.

The GetRequest may read an object value of a specific object by an administrator, and the GetNextRequest may obtain a next object value of an object value specified by the manager or a next index value when the specified object is a table. SetRequest allows an administrator to change the value of an object in a delegate. SendTrapRequest can generate traps, specific contextual information, and TrapAnalyzer can analyze traps from SNMP agents. Here, the TrapAnalyzer function analyzes the generated packet directly without sending it to the agent via UDP socket.

For example, the message handler 220 or 230 notifies the API function 240 that the kind of control command PDU is Get by calling the GetRequest function or that the kind of control command is Set by calling the SetRequest function.

Although the operation by type of the SNMP API function 240 will be described in detail below, the main feature of the present invention is to provide an SNMP API for processing SNMP packets using a function of the epilogue tool between a message handler and an agent, thereby providing a message. It should be understood that handlers can automatically handle actions that had to be handled by the user inside an API function. Therefore, the description of the operation of each API function to be described later is merely to help the understanding of the present invention, other applications are possible.

1. GetRequest

The input format of the GetRequest command according to the present invention is as follows.

GetRequest (char * ip_addr, char * community, int str_count, VALUE_LIST * in_value_list, VALUE_LIST * out_value_list, char * err_msg)

Here, the argument ip_addr is a string pointer indicating a location where the agent's IP address is stored. The community is a community string pointer indicating a location where a community string for communicating with an agent is stored, and performs a cryptographic function for minimal authentication. The str_count is the number of Manager Objects (MOs) for which the value is to be obtained. The in_value_list is a VALUE_LIST pointer indicating a location where a list of object (MO) values for which the value is to be obtained is stored. The out_value_list is a VALUE_LIST pointer indicating a location where a list of object values answered with GetResponse is stored. The err_msg is a string pointer indicating a location where an error message returned when an error occurs.

The message handler processes such variables input from the user into a form that can call an API function, and then enters the GetRequest API function.

The value of an object obtained from the management object by the GetRequest is stored in a previously created VALUE_LIST structure, and an example of the VALUE_LIST structure is shown in Table 1 below.

TABLE 1

typedef struct _VALUE_LIST {

char name [256];

OCTET_T value_type;

union {

INT_32_T v_number;

UNIT_32_T v_counter;

EBUFFER_T v_string;

OBJ_ID_T v_object;

unsigned char v_network_address [4];

UNIT_64_T v_counter64;

} value_u;

} VALUE_LIST;

Hereinafter, the operation of the GetRequest command configured as described above will be described.

When the GetRequest API control command is called by the message handlers 220 and 230 shown in FIG. 2, the GetRequest API function receives an MO name of an object to get its value into an array of the VALUE_LIST structure. . The object name is an object ID (OID) string (for example, 1.3.6.1.4.1.236.36.3.4.1.4.1.2) or an index value whose name string in the VALUE_LIST structure contains the index value of the table. It is entered in the form of the included object name string (for example, slotCardAdminStatus.1.2).

The GetRequest function converts a string entered in the form of a number or object name into an object ID (OID). The GetRequest function binds the object IDs of the management objects input by str_count and SNMP encodes them, and sends them through the UDP socket to the input IP address. In transmission, authentication process is performed using the input community. After that, the GetRequest function receives the response to the GetRequest, that is, the GetResponse data through the UDP socket, decodes the SNMP, and checks an error state.

If there is no error as a result of the check, the VALUE_LIST bound to GetResponse is analyzed and divided into the object ID and the object value, and the divided object ID is converted into the object name string including the index. All converted object names and their values are stored in the VALUE_LIST structure as out_value_list and returned to the message handler.

If the check results in an error, the reason for the failure (error code) of the SNMP packet is output in err_msg, and err_msg is returned to the message handler.

2. GetNextRequest

The input format of the GetNextRequest command according to the present invention is as follows.

GetNextRequest (char * ip_addr, char * community, int str_count, VALUE_LIST * in_value_list, VALUE_LIST * out_value_list, char * err_msg)

The meanings of the variables and the structure of VALUE_LIST are the same as in the case of GetRequest.

Hereinafter, the operation of the GetNextRequest command configured as described above will be described.

When the GetNextRequest API control command is called by the message handlers 220 and 230 shown in FIG. 2, the GetNextRequest API function receives the name of the object MO to be GetNext in an array of the VALUE_LIST structure. The object name is entered in the name string of the VALUE_LIST structure in the form of an object ID string (eg 1.3.6.1.4.1.236.36.3.4.1.4.1) or an object name string (eg slotCardAdminStatus.1).

The GetNextRequest function converts a string entered in the form of a number or object name into an object ID. The GetNextRequest function binds the object IDs of the objects input by str_count and then encodes them in SNMP and sends them through the UDP socket to the input IP address. Thereafter, the GetNextRequest function receives the response to the GetNextRequest, that is, the GetResponse data through the UDP socket, decodes the SNMP, and checks an error state.

If there is no error as a result of the check, the VALUE_LIST bound to GetResponse is analyzed and divided into an object ID and an object value, and the divided object ID is converted into an object name string including an index. All converted object names and object values are stored in the VALUE_LIST structure as out_value_list and returned to the message handler.

If the check results in an error, the reason for the failure (error code) of the SNMP packet is output in err_msg, and err_msg is returned to the message handler.

3. SetRequest

The input format of the SetRequest command according to the present invention is as follows.

SetRequest (char * ip_addr, char * community, int str_count, VALUE_LIST * in_value_list, VALUE_LIST * out_value_list, char * err_msg)

The meanings of the variables and the structure of VALUE_LIST are the same as in the case of GetRequest.

Hereinafter, the operation of the SetRequest command configured as described above will be described.

When the SetRequest API control command is called by the message handlers 220 and 230 shown in FIG. 2, the SetRequest API function receives an object (MO) name, an object value type, and an object value to be set in an array of a VALUE_LIST structure. . The object name can be either the object ID string (1.3.6.1.4.1.236.36.3.4.1.8.1.3) containing the index value in the name string of the VALUE_LIST structure or the object name string (for example, slotCardReset.3.1) containing the index value. It is input in the form.

The type of the object value is stored as an integer value defined in the object type of the VALUE_LIST structure, wherein an example of the object type is VT_NUMBER, VT-STRING, VT-BITS, VT_OBJECT, VT_EMPTY, VT_IPADDRESS, VT_COUNTER, VT_GAUGE , VT_TIMETICKS, VT_OPAQUE, and VT_COUNTER64.

In addition, the object value is stored in the value_u union of the VALUE_LIST structure according to the object type.

The SetRequest function converts a string input in the number or object name format into an object ID format. The SetRequest function binds the object ID and the object value of the objects input by str_count according to the object value type and then SNMP encodes them and sends them through the UDP socket to the input IP address. Thereafter, the SetRequest function receives an answer to the SetRequest, that is, GetResponse data through the UDP socket, decodes the SNMP, and checks an error state.

If there is no error as a result of the check, the VALUE_LIST bound to GetResponse is analyzed and divided into an object ID and an object value, and the divided object ID is converted into an object name string including an index. All converted object names and object values are stored in the VALUE_LIST structure as out_value_list and returned to the message handler.

If the check results in an error, the reason for the failure (error code) of the SNMP packet is output in err_msg, and err_msg is returned to the message handler.

4. SendTrapRequest

The input format of the SendTrapRequest command according to the present invention is as follows.

SendTrapRequest (char * ip_addr, char * community, char * enterprise, int trap_type, int str_count, VALUE_LIST * trap_list, char * err_msg)

The meanings of the variables and the structure of VALUE_LIST are the same as in the case of GetRequest. The enterprise is a string pointer indicating a management object name (Enterprise MO name) that is a subject when SNMP version 1 is used, and the trap_type is used by SNMP version 1 If it is specified, it indicates a specific trap type, str_count is the number of managed objects to bind when the trap is created, and trap_list is a VALUE_LIST pointer indicating a list of managed objects to be bound.

The message handler calls the SendTrapRequest API function to generate a trap to another device or module with respect to its state.

Hereinafter, the operation of the SendTrapRequest command configured as described above will be described.

When the SendTrapRequest API control command is called by the message handlers 220 and 230 shown in Fig. 2, the SendTrapRequest API function generates a trap or trap 2 according to the version of SNMP. Because traps and traps2 have different formats, they can only be recognized by managers and agents using the same version. The SendTrapRequest function generates a trap according to version 1 if the enterprise string is entered and a trap 2 according to version 2 if not entered. The enterprise string is a value for notifying an entity generating a trap in SNMP version 1, and usually means a specific management object used by each company or equipment.

In version 1, the SendTrapRequest function converts the value of the entered subject management object into the object ID form, and then generates an SNMP trap packet using the type of trap entered. The SendTrapRequest function converts the input str_count objects and object value lists into object IDs and object values, respectively, and binds them to the generated SNMP trap packets.

In version 2, the SendTrapRequest function generates an SNMP Trap2 packet using the standard sysUpTime and snmpTrapOID. The Standard sysUpTime is a management object defined in the standard RFC1213, and means a time from when the system is started up to the present. The object ID value is 1.3.6.1.2.1.3.0, and the snmpTrapOID is defined in the standard RFC1907. Authentication object ID used when sending traps in SNMP version 2 as a management object. The value is 1.3.6.1.6.3.1.1.4.1.0.

The SendTrapRequest function converts the input str_count object and the object value list into the object ID and the object value, and binds the generated SNMP trap 2 packet.

The generated SNMP trap packet or SNMP trap 2 packet is SNMP encoded by the SendTrapRequest function and transmitted through a UDP socket to an input IP address. SNMP trap packets or SNMP trap2 packets generated by the SendTrapRequest function are sent to other applications or user interfaces above the manager.

If an error occurs during the transmission of the trap or trap 2 packet, SendTrapRequest outputs a reason (error code) to err_msg and returns err_msg to the message handler.

The SendTrapRequest function, which works as described above, can be used to send a trap to a manager if necessary.

5. TrapAnalyzer

The input format of the TrapAnalyzer command according to the present invention is as follows.

TrapAnalyzer (unsigned char * rcvbuff, int bufcnt, SNMPADDR_T * psrc, SNMPADDR_T * pdst, int * version, TRAP_HEAD * trap_head, int vb_count, VALUE_LIST * trap_list, char * err_msg)

The rcvbuff is a pointer of a buffer in which trap data is received through a UDP socket, the bufcnt is a data length of the rcvbuff, and the psrc is a socket address (sockaddr) structure pointer of a source, ie, an agent, that sent the UDP data. Where pdst is a destination that received the UDP data, that is, a socket address structure pointer of an administrator, version is a version of a received SNMP packet, and trap_head is a header structure pointer of a received SNMP trap or trap 2. Vb_count is the number of bound objects of the received SNMP trap or trap 2, and the trap_list is a VALUE_LIST pointer indicating the object list of the received SNMP trap or trap 2.

The result analyzed by the TrapAnalyzer is stored in a previously generated TRAP_HEAD structure, which is shown in Table 2 below.

TABLE 2

typedef struct TRAP_HEAD {

OBJ_ID_T enterprise_obj;

unsigned char agent_addr [4];

INT_32_T generic_trap;

INT_32_T specific_trap;

UNIT_32_T trap_timeticks;

} TRAP_HEAD;

In addition, the structure of the VALUE_LIST is as in the case of GetRequest (Table 1).

The operation of the TrapAnalyzer command configured as described above will be described below.

The TrapAnalyzer function checks the type of data stored in the buffer. At this time, since the data stored in the buffer is the final data for SNMP data transmission, the TrapAnalyzer function is difficult to read. Therefore, the TrapAnalyzer function generates SNMP packets that can be read by the API function by SNMP decoding the data of the buffer according to the address, data length, source address, and destination address of the buffer into which data is input through the UDP socket. Check whether the PDU Type of the control command is a trap.

If the generated SNMP packet is a trap, the TrapAnalyzer function obtains the subject object ID and delegate address, generic trap type, specific trap type, and trap timeticks and stores them in the TRAP_HEAD structure. do.

The general trap types may include coldStart (0), warmStart (1), linkDown (2), linkUp (3), authenticationFailure (4), egpNeighborLoss (5), and enterprise specific (6). The specific trap type is meaningful only when the value of the general trap type is enterpriseSpecific (6), and may include acctLogFileFull (1), faultLogFileFull (2), and loopbackResultTrap (3). Also, the trap timetics is the value of sysUpTime entered by the agent that generated the trap, that is, the time since the agent system started up.

TrapAnalyzer analyzes the bound list of object values, breaks them up into object IDs and object values, and then converts the divided object IDs to object name strings containing indices. All converted object names and the object values are stored in the VALUE_LIST structure and returned to the message handler. The value returned to the message handler is a version of the received SNMP packet (version), a header structure pointer (trap_head) of the SNMP trap, the number of bound objects (vb_count) of the SNMP trap, and a VALUE_LIST pointer indicating the object list of the SNMP trap ( trap_list).

When an error occurs in the converted SNMP packet, the TrapAnalyzer outputs a reason (error code) to err_msg and returns err_msg.

As described above, in the operation of the SNMP API function according to the present invention, if the integer value of err_msg returned by the SNMP API function is '0', no error occurs. If not, the error occurs. to be. The non-zero integer values returned are predefined error codes to indicate the reason for failure. An example of the meaning is shown in Table 3 below.

TABLE 3

0x11: too big (SNMP response error)

0x12: no such name (SNMP response error)

0x13: bad value (SNMP response error)

0x14: read only (SNMP response error)

0x15: general error (SNMP response error)

0x16: no access (SNMP response error)

0x17: wrong type (SNMP response error)

0x18: wrong length (SNMP response error)

0x19: wrong encoding (SNMP response error)

0x1A: wrong value (SNMP response error)

0x1B: no creation (SNMP response error)

0x1C: inconsistent value (SNMP response error)

0x1D: resource unavailable (SNMP response error)

0x1E: commit failed (SNMP response error)

0x1F: undo failed (SNMP response error)

0x20: authorization error (SNMP response error)

0x21: not writable (SNMP response error)

0x22: inconsistent name (SNMP response error)

0x23: can't find MO in the MIB table

0x24: can't make MIB table

0x25: can't find response MO in the MIB table

0x26: need to specify destination first

0x27: error creating SNMP request

0x28: no oid entry

0x29: internal buffer exceeded, OID to long

0x2A: can't get socket

0x2B: sendto failed

0x2C: recv timeout failed

0x2D: recvfrom failed

0x2F: error in SNMP decode of received packet

0x30: can't find Enterprise MO in the MIB

0x31: can't Decode received data

0x32: Decode error

0x33: Don't know the variable type for set, try to set instead

0x34: V2 type request but V2 type code isn't installed

0x35: unknown value type

0x36: No memory

0x37: Error creating trap packet

0x38: Error creating trap2 packet

0x39: SNMP bind integer error

0x3A: SNMP bind object error

As described above, in the detailed description of the present invention, specific embodiments have been described, but various modifications are possible without departing from the scope of the present invention. Therefore, the scope of the present invention should not be limited to the described embodiments, but should be defined not only by the scope of the following claims, but also by the equivalents of the claims.

In the present invention operating as described in detail above, the effects obtained by the representative ones of the disclosed inventions will be briefly described as follows.

The present invention provides an SNMP API that is called by a message handler to generate an SNMP packet using a function of the epilogue tool, so that anyone can easily call the program. There is no need to understand the individual operations inside the API, minimizing human tasks for SNMP communication.

In addition, the present invention has the effect of optimizing the code of the SNMP interface program to eliminate the redundant coding at the time of program creation, and to facilitate the debug by providing an error code of the SNMP API.

Claims (11)

In a method for multiple message handlers in a simple network management protocol (SNMP) manager to manage an SNMP agent of a network element using an epilogue tool, A first step in which each message handler calls an SNMP API, which is an application programming interface (API) function of a control command (PDU) for managing the SNMP agent; And a second step in which the called SNMP API executes a control command for managing an SNMP agent using the epilogue tool, and returns a result to the message handler. The method of claim 1, wherein the called SNMP API, An SNMP communication method using the API, which is a GetRequest API function for obtaining a value of a specific management object (MO) designated by an administrator. The method of claim 2, wherein the second step, Generating an SNMP packet by the GetRequest API function to obtain a value of a specific management object; Transmitting the generated SNMP packet to the SNMP agent through a UDP socket; Checking the error status of the data replied to the transmission; If there is no error as a result of the check, returning all object names and object values included in the answered data to the message handler; And If there is an error as a result of the check, returning a predefined error code indicating a failure reason to the message handler. The method of claim 1, wherein the SNMP API, An SNMP communication method using the API, which is a GetNextRequest API function for retrieving the next index value of a specific object designated by an administrator or the specified index is a table. The method of claim 4, wherein the second step, Generating, by the GetRequest API function, an SNMP packet for retrieving a next object value or a next index value of a specific object; Transmitting the generated SNMP packet to the SNMP agent through a UDP socket; Checking the error status of the data replied to the transmission; If there is no error as a result of the check, returning all object names and object values included in the answered data to the message handler; And If there is an error as a result of the check, returning a predefined error code indicating a failure reason to the message handler. The method of claim 1, wherein the SNMP API, An SNMP communication method using the API, which is a SetRequest API function for changing a specific object value of a delegate. The method of claim 6, wherein the second step, Generating an SNMP packet by the SetRequest API function to change a value of a specified specific object; Transmitting the generated SNMP packet to the SNMP agent through a UDP socket; Checking the error status of the data replied to the transmission; If there is no error as a result of the check, returning all object names and object values included in the answered data to the message handler; And If there is an error as a result of the check, returning a predefined error code indicating a failure reason to the message handler. The method of claim 1, wherein the SNMP API, SNMP communication method using API, which is a SendTrapRequest API function for generating a trap, which is specific situation information generated from an SNMP manager. The method of claim 8, wherein the second step, Generating, by the SendTrapRequest API function, an SNMP trap packet according to an SNMP version; Transmitting the generated SNMP trap packet to a designated destination through a UDP socket; And If an error occurs during the transmission, returning a predefined error code indicating a failure reason to the message handler. The method of claim 1, wherein the SNMP API, SNMP communication method using an API, which is a TrapAnalyzer API function for analyzing a trap obtained from the SNMP agent. The method of claim 10, wherein the second step, Generating, by the TrapAnalyzer API function, SNMP decoding the data in the buffer received from the SNMP agent to generate an SNMP packet; Checking whether the generated SNMP packet is a trap; If the generated SNMP packet is a trap, returning all object names, object values, and traps obtained from the SNMP packet to a message handler; And If an error occurs in the generated SNMP packet, further comprising returning a predefined error code indicating a failure reason to the message handler.