Get MAX-TNT port count/status

tnt-port-count.c

#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

#define ADMIN_UP	1
#define ADMIN_DOWN	2
#define ADMIN_REMOVED	3
#define ADMIN_MAINT	4

#define OPER_DOWN	1
#define OPER_UP		2
#define OPER_DIAG	3
#define OPER_COREDUMP	4
#define OPER_LOADING	5
#define OPER_POST	6
#define OPER_NONE	7
#define OPER_OCCUPIED	8
#define OPER_MAINT	9

#define CARD_OTHER	1
#define CARD_EMPTY	2
#define CARD_8T1	4
#define CARD_T3		29
#define CARD_OCCUPIED	80
#define CARD_MADD2	93

#define	PORT_UNKNOWN	1
#define PORT_NOTEXIST	2
#define PORT_DISABLED	3
#define PORT_NOPHYSICAL	4
#define PORT_NOLOGICAL	5
#define PORT_PTP	6
#define PORT_MP1	7
#define PORT_MP2	8
#define PORT_LOS	9
#define PORT_YELLOW	10
#define PORT_AIS	11
#define PORT_NODCHAN	12
#define PORT_ACTIVE	13
#define PORT_MAINT	14

struct portinfo {
	int status;
	int chans;
	int avail;
	char name[32];
	char status_str[32];
};

struct portinfo get_port_info(struct snmp_session *ss, int port_idx)
{
	struct snmp_pdu *pdu, *response;
	struct variable_list *vars;
	struct portinfo pinfo;
	int status = -1;
	int chans = -1;
	int avail = -1;
	char name[32];
	char status_str[32];

	oid status_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 21, 1, 5, port_idx };
	size_t status_len = sizeof(status_oid) / sizeof(oid);

	oid name_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 21, 1, 2, port_idx };
	size_t name_len = sizeof(name_oid) / sizeof(oid);

	oid chans_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 21, 1, 4, port_idx };
	size_t chans_len = sizeof(chans_oid) / sizeof(oid);

	oid avail_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 21, 1, 12, port_idx };
	size_t avail_len = sizeof(avail_oid) / sizeof(oid);

	pdu = snmp_pdu_create(SNMP_MSG_GET);
	snmp_add_null_var(pdu, status_oid, status_len);
	snmp_add_null_var(pdu, name_oid, name_len);
	snmp_add_null_var(pdu, chans_oid, chans_len);
	snmp_add_null_var(pdu, avail_oid, avail_len);

	status = snmp_synch_response(ss, pdu, &response);
	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		for (vars = response->variables; vars; vars = vars->next_variable) {
			if (vars->name_length == status_len && !memcmp(status_oid, vars->name, sizeof(status_oid))) {
				status = *vars->val.integer;
				switch (status) {
					case PORT_UNKNOWN:
						snprintf(status_str, sizeof(status_str), "unknown");
						break;
					case PORT_NOTEXIST:
						snprintf(status_str, sizeof(status_str), "does not exist");
						break;
					case PORT_DISABLED:
						snprintf(status_str, sizeof(status_str), "disabled");
						break;
					case PORT_NOPHYSICAL:
						snprintf(status_str, sizeof(status_str), "no physical connection");
						break;
					case PORT_NOLOGICAL:
						snprintf(status_str, sizeof(status_str), "no logical connection");
						break;
					case PORT_PTP:
						snprintf(status_str, sizeof(status_str), "point to point");
						break;
					case PORT_MP1:
						snprintf(status_str, sizeof(status_str), "multipoint-1");
						break;
					case PORT_MP2:
						snprintf(status_str, sizeof(status_str), "multipoint-2");
						break;
					case PORT_LOS:
						snprintf(status_str, sizeof(status_str), "loss of sync");
						break;
					case PORT_YELLOW:
						snprintf(status_str, sizeof(status_str), "yellow alarm");
						break;
					case PORT_AIS:
						snprintf(status_str, sizeof(status_str), "ais");
						break;
					case PORT_NODCHAN:
						snprintf(status_str, sizeof(status_str), "no d channel");
						break;
					case PORT_ACTIVE:
						snprintf(status_str, sizeof(status_str), "active");
						break;
					case PORT_MAINT:
						snprintf(status_str, sizeof(status_str), "maintenance");
						break;
					default:
						snprintf(status_str, sizeof(status_str), "unknown");
						break;
				}
			}

			if (vars->name_length == chans_len && !memcmp(chans_oid, vars->name, sizeof(name_oid))) {
				chans = *vars->val.integer;
			}

			if (vars->name_length == avail_len && !memcmp(avail_oid, vars->name, sizeof(avail_oid))) {
				avail = *vars->val.integer;
			}

			if (vars->name_length == name_len && !memcmp(name_oid, vars->name, sizeof(name_oid))) {
				if (vars->val_len == 0) {
					snprintf(name, sizeof(name), "<unknown>");
				} else {
					strncpy(name, vars->val.string, vars->val_len);
					name[vars->val_len] = '\0';
				}
			}
		}
	} else {
		if (status == STAT_SUCCESS) {
			printf("Error in packet. reason: %s\n", snmp_errstring(response->errstat));
		} else {
			snmp_sess_perror("snmpget", ss);
		}
	}

	if (response) {
		snmp_free_pdu(response);
	}

	pinfo.status = status;
	pinfo.chans = chans;
	pinfo.avail = avail;
	strncpy(pinfo.name, name, sizeof(name));
	strncpy(pinfo.status_str, status_str, sizeof(status_str));

	return pinfo;
}

int main(int argc, char **argv)
{
	struct snmp_session session, *ss;
	struct snmp_pdu *pdu, *response;
	struct variable_list *vars;
	int i, status, active = 0, available = 0, slots = 0;

	oid active_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 26, 0 };
	size_t active_len = sizeof(active_oid) / sizeof(oid);
 
	oid available_oid[] = { 1, 3, 6, 1, 4, 1, 529, 4, 23, 0 };
	size_t available_len = sizeof(available_oid) / sizeof(oid);

	oid slots_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 1, 0 };
	size_t slots_len = sizeof(slots_oid) / sizeof(oid);
 
	if (argc != 3) {
		printf("%s <chassis ip> <community>\n", argv[0]);
		return -1;
	}

	init_snmp("snmpapp");
	snmp_sess_init(&session);
	session.peername = strdup(argv[1]);
	session.version = SNMP_VERSION_1;
	session.community = argv[2];
	session.community_len = strlen(argv[2]);

	SOCK_STARTUP;
	ss = snmp_open(&session);
	if (!ss) {
		snmp_perror("snmp_open");
		snmp_log(LOG_ERR, "could not establish snmp session\n");
		exit(2);
	}

	pdu = snmp_pdu_create(SNMP_MSG_GET);
	snmp_add_null_var(pdu, active_oid, active_len);
	snmp_add_null_var(pdu, available_oid, available_len);
	snmp_add_null_var(pdu, slots_oid, slots_len);

	status = snmp_synch_response(ss, pdu, &response);
	if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
		for (vars = response->variables; vars; vars = vars->next_variable) {
			if (vars->name_length == active_len && !memcmp(active_oid, vars->name, sizeof(active_oid))) {
				active = *vars->val.integer;
			}

			if (vars->name_length == available_len && !memcmp(available_oid, vars->name, sizeof(available_oid))) {
				available = *vars->val.integer;
			}

			if (vars->name_length == slots_len && !memcmp(slots_oid, vars->name, sizeof(slots_oid))) {
				slots = *vars->val.integer;
			}
		}
	} else {
		if (status == STAT_SUCCESS) {
			printf("Error in packet. reason: %s\n", snmp_errstring(response->errstat));
		} else {
			snmp_sess_perror("snmpget", ss);
		}
	}

	if (response) {
		snmp_free_pdu(response);
	}

	printf("active: %d, total: %d\n\n", active, active + available);
	printf("Slot\tCard\n");
	printf("----\t----\n");

	for (i = 1; i <= slots; i++) {
		int oper = -1;
		int admin = -1;
		int ports = -1;
		int card_type = -1;
		int j = 0;
		int running = 0;
		char *card_str;

		oid oper_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 2, 1, 8, i };
		size_t oper_len = sizeof(oper_oid) / sizeof(oid);
 
		oid admin_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 2, 1, 12, i };
		size_t admin_len = sizeof(admin_oid) / sizeof(oid);
 
		oid card_str_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 2, 1, 2, i };
		size_t card_str_len = sizeof(card_str_oid) / sizeof(oid);
 
		oid card_type_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 2, 1, 3, i };
		size_t card_type_len = sizeof(card_type_oid) / sizeof(oid);
 
		oid ports_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 2, 1, 5, i };
		size_t ports_len = sizeof(ports_oid) / sizeof(oid);
 
		oid port_indexes_oid[] = { 1, 3, 6, 1, 4, 1, 529, 2, 3, 1, 3, i };
		size_t port_indexes_len = sizeof(port_indexes_oid) / sizeof(oid);

		oid name[MAX_OID_LEN];
		size_t name_len;
 
		pdu = snmp_pdu_create(SNMP_MSG_GET);
		snmp_add_null_var(pdu, oper_oid, oper_len);
		snmp_add_null_var(pdu, admin_oid, admin_len);
		snmp_add_null_var(pdu, card_str_oid, card_str_len);
		snmp_add_null_var(pdu, card_type_oid, card_type_len);
		snmp_add_null_var(pdu, ports_oid, ports_len);

		status = snmp_synch_response(ss, pdu, &response);
		if (status == STAT_SUCCESS && response->errstat == SNMP_ERR_NOERROR) {
			for (vars = response->variables; vars; vars = vars->next_variable) {
				if (vars->name_length == oper_len && !memcmp(oper_oid, vars->name, sizeof(oper_oid))) {
					oper = *vars->val.integer;
				}

				if (vars->name_length == admin_len && !memcmp(admin_oid, vars->name, sizeof(admin_oid))) {
					admin = *vars->val.integer;
				}

				if (vars->name_length == card_str_len && !memcmp(card_str_oid, vars->name, sizeof(card_str_oid))) {
					card_str = malloc(vars->val_len + 1);
					if (card_str == NULL) {
						perror("malloc");

						if (response)
							snmp_free_pdu(response);

						snmp_close(ss);
						SOCK_CLEANUP;

						return -1;
					}

					strncpy(card_str, vars->val.string, vars->val_len);
					card_str[vars->val_len] = '\0';
				}

				if (vars->name_length == card_type_len && !memcmp(card_type_oid, vars->name, sizeof(card_type_oid))) {
					card_type = *vars->val.integer;
				}

				if (vars->name_length == ports_len && !memcmp(ports_oid, vars->name, sizeof(ports_oid))) {
					ports = *vars->val.integer;
				}
			}
		} else {
			if (status == STAT_SUCCESS) {
				printf("error in packet. reason: %s\n", snmp_errstring(response->errstat));
			} else {
				snmp_sess_perror("snmpget", ss);
			}
		}

		if (response) {
			snmp_free_pdu(response);
		}

		printf("%d\t%s (", i, card_str);
		switch(admin) {
			case ADMIN_UP:
				printf("up");
				break;
			case ADMIN_DOWN:
				printf("down");
				break;
			case ADMIN_REMOVED:
				printf("removed");
				break;
			case ADMIN_MAINT:
				printf("maintenance");
				break;
			default:
				printf("unknown");
				break;
		}

		printf("/");
		switch(oper) {
			case OPER_DOWN:
				printf("down");
				break;
			case OPER_UP:
				printf("up");
				break;
			case OPER_DIAG:
				printf("diag");
				break;
			case OPER_COREDUMP:
				printf("coredump");
				break;
			case OPER_LOADING:
				printf("loading");
				break;
			case OPER_POST:
				printf("post");
				break;
			case OPER_NONE:
				printf("none");
				break;
			case OPER_OCCUPIED:
				printf("occupied");
				break;
			case OPER_MAINT:
				printf("maintenance");
				break;
			default:
				printf("unknown");
				break;
		}

		printf("): %d ports\n", ports);
		free(card_str);

		if (card_type == CARD_8T1 || card_type == CARD_T3) {
			j = 1;
			running = 1;

			memmove(name, port_indexes_oid, port_indexes_len * sizeof(oid));
			name_len = port_indexes_len;

			while (running) {
				pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
				snmp_add_null_var(pdu, name, name_len);

				status = snmp_synch_response(ss, pdu, &response);
				if (status == STAT_SUCCESS) {
					if (response->errstat == SNMP_ERR_NOERROR) {
						pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
						for (vars = response->variables; vars; vars = vars->next_variable) {
							if (vars->name_length >= port_indexes_len || !memcmp(port_indexes_oid, vars->name, sizeof(port_indexes_oid))) {
								int port_index;
								struct portinfo pinfo;

								port_index = *vars->val.integer;
								memmove((char *)name, (char *)vars->name, vars->name_length * sizeof(oid));
								name_len = vars->name_length;

								pinfo = get_port_info(ss, port_index);
								if (pinfo.status == PORT_ACTIVE) {
									printf("\t%d: %s (%d of %d in use)\n", j, pinfo.name, pinfo.chans - pinfo.avail, pinfo.chans);
								} else {
									printf("\t%d: %s (%s)\n", j, pinfo.name, pinfo.status_str);
								}

								j++;
								if (j > ports) {
									running = 0;
									continue;
								}
							} else {
								running = 0;
								continue;
							}
						}
					} else {
						running = 0;

						if (response->errstat != SNMP_ERR_NOSUCHNAME)
							printf("Error in packet. reason: %s\n", snmp_errstring(response->errstat));
						else
							snmp_sess_perror("snmpget", ss);
					}
				} else {
					running = 0;
					snmp_sess_perror("snmpget", ss);
				}

				if (response)
					snmp_free_pdu(response);
			}
		}

		printf("\n");
	}

	snmp_close(ss);
	SOCK_CLEANUP;

	return 0;
}