void refreshInterfaceData(struct lldp_port *lldp_port) { _getmac(lldp_port); debug_printf(DEBUG_INT, "%s MAC: ", lldp_port->if_name); debug_hex_printf(DEBUG_INT, lldp_port->source_mac, 6); _getip(lldp_port); debug_printf(DEBUG_INT, "%s IP: %d.%d.%d.%d\n", lldp_port->if_name, lldp_port->source_ipaddr[0], lldp_port->source_ipaddr[1], lldp_port->source_ipaddr[2], lldp_port->source_ipaddr[3]); }
int do_v1_at_mac(struct generic_eap_data *thisint, char *K_int, char *indata, int in_size, int inoffset, char *noncemt, char *vlist, int vlistlen, uint16_t selver, char *resultmac) { char *framecpy, *mac_calc; int saved_offset, i; uint16_t value16; if ((!thisint) || (!K_int) || (!indata) || (!noncemt) || (!vlist) || (!resultmac)) { debug_printf(DEBUG_NORMAL, "Invalid data passed to do_v1_at_mac()!\n"); return XEMALLOC; } if (indata[inoffset] != AT_MAC) { debug_printf(DEBUG_NORMAL, "Error! The offset passed in is not of type AT_MAC!\n"); return -1; } inoffset++; if (indata[inoffset] != 5) printf("AT_MAC length isn't 5!\n"); inoffset+=2; // Skip the reserved bytes. saved_offset = inoffset; framecpy = (char *)malloc(in_size+50); // We need extra to // reconstruct the eap // piece. if (framecpy == NULL) { printf("Couldn't allocate memory for framecpy!\n"); return -1; } // Now, reconstruct the header for the EAP piece, so we can // calculate the MAC across all of it. framecpy[0] = 1; // It was a request. framecpy[1] = thisint->eapid; value16 = in_size + 5; value16 = htons(value16); memcpy((char *)&framecpy[2], &value16, 2); framecpy[4] = 18; // EAP-SIM memcpy((char *)&framecpy[5], (char *)&indata[0], in_size); // Now, zero out the MAC value. for (i=(saved_offset+5);i<=(in_size+5);i++) { framecpy[i] = 0x00; } memcpy(&framecpy[(in_size+5)], noncemt, 16); // We should now be ready to calculate the AT_MAC for // ourselves. debug_printf(DEBUG_AUTHTYPES, "Hashing this frame to get AT_MAC: \n"); debug_hex_dump(DEBUG_AUTHTYPES, framecpy, (in_size+5+16)); mac_calc = (char *)malloc(100); if (mac_calc == NULL) return -1; HMAC(EVP_sha1(), &K_int[0], 16, framecpy, (in_size+5+16), mac_calc, &i); memcpy(resultmac, mac_calc, 16); // We get 20 back, but we only want 16. debug_printf(DEBUG_AUTHTYPES, "Result MAC = "); debug_hex_printf(DEBUG_AUTHTYPES, resultmac, 16); free(framecpy); framecpy = NULL; free(mac_calc); mac_calc = NULL; return 0; }
int eapsim_process(struct generic_eap_data *thisint, u_char *dataoffs, int insize, u_char *out, int *outsize) { int packet_offset, outptr, numVers, i, value16, maxver, saved_offset; int tlen; struct typelength *typelen; struct typelengthres *typelenres; struct eaptypedata *mydata; char *hash, *at_mac_sres, *nsres=NULL, *framecpy, *username; char sha1resp[20], K_sres[16], K_encr[16], K_recv[32], K_send[32]; char mac_val[16], mac_calc[16], K_int[16]; struct config_eap_sim *userdata; if ((!thisint) || (!thisint->eap_data)) { debug_printf(DEBUG_NORMAL, "Invalid interface struct passed in to eapsim_process()!\n"); return XEMALLOC; } mydata = (struct eaptypedata *)thisint->eap_data; userdata = (struct config_eap_sim *)thisint->eap_conf_data; if (!userdata) { debug_printf(DEBUG_NORMAL, "Invalid user data struct in eapsim_process()!\n"); return XEMALLOC; } if ((thisint->tempPwd == NULL) && (userdata->password == NULL)) { thisint->need_password = 1; thisint->eaptype = strdup("EAP-SIM"); thisint->eapchallenge = NULL; *outsize = 0; return XENONE; } // Make sure we have something to process... if (dataoffs == NULL) return XENONE; if (sc_need_init()==1) { init_smartcard(thisint); } if (userdata->username == NULL) { username = thisint->identity; } else { username = userdata->username; } if ((userdata->password == NULL) && (thisint->tempPwd != NULL)) { userdata->password = thisint->tempPwd; thisint->tempPwd = NULL; } *outsize = 0; bzero(&mac_calc[0], 16); bzero(&mac_val[0], 16); switch (dataoffs[0]) { case SIM_START: debug_printf(DEBUG_AUTHTYPES, "Got SIM_START!\n"); bzero(out, 100); packet_offset = 3; typelen = (struct typelength *)&out[0]; typelen->type = SIM_START; typelen->length = 0; typelenres = (struct typelengthres *)&out[3]; typelenres->type = AT_NONCE_MT; typelenres->length = 5; typelenres->reserved = 0; // Generate a few random bytes for our NONCE MT. mydata->nonce_mt = (char *)malloc(16); if (mydata->nonce_mt == NULL) return XEMALLOC; RAND_bytes(mydata->nonce_mt,16); debug_printf(DEBUG_AUTHTYPES, "NONCE MT = "); debug_hex_printf(DEBUG_AUTHTYPES, mydata->nonce_mt, 16); outptr = 7; memcpy(&out[outptr], mydata->nonce_mt, 16); outptr += 16; // Process SIM value fields. while (packet_offset < insize) { switch (dataoffs[packet_offset]) { case AT_MAC: debug_printf(DEBUG_NORMAL, "You cannot have an AT_MAC in a Start packet!\n"); return XESIMNOATMAC; case AT_ANY_ID_REQ: case AT_FULLAUTH_ID_REQ: case AT_PERMANENT_ID_REQ: debug_printf(DEBUG_AUTHTYPES, "Got AT_FULLAUTH_ID_REQ or AT_PERMANENT_ID_REQ!\n"); typelenres = (struct typelengthres *)&dataoffs[packet_offset]; if ((typelenres->length != 5) && (typelenres->length != 1)) { debug_printf(DEBUG_NORMAL, "Invalid AT_FULLAUTH_ID_REQ length!\n"); return XESIMBADLEN; } packet_offset+=4; // Skip the reserved and length bytes. // Build an AT_IDENTITY response. typelenres = (struct typelengthres *)&out[outptr]; typelenres->type = AT_IDENTITY; typelenres->length = (strlen(username)/4)+1; typelenres->reserved = htons(strlen(username)); outptr+=sizeof(struct typelengthres); memcpy(&out[outptr], username, strlen(username)); outptr += strlen(username); break; case AT_VERSION_LIST: debug_printf(DEBUG_AUTHTYPES, "Got an AT_VERSION_LIST request!\n"); typelenres = (struct typelengthres *)&dataoffs[packet_offset]; debug_printf(DEBUG_AUTHTYPES, "Version List Length (# versions) : %d\n", typelenres->length); numVers = typelenres->length; mydata->verlistlen = ntohs(typelenres->reserved); debug_printf(DEBUG_AUTHTYPES, "Version List Length (bytes) : %d\n", mydata->verlistlen); packet_offset+=sizeof(struct typelengthres); maxver = 0; // Set the starting value to be 0. mydata->verlist = (char *)malloc(mydata->verlistlen); if (mydata->verlist == NULL) return XEMALLOC; memcpy(mydata->verlist, &dataoffs[packet_offset], mydata->verlistlen); for (i=0;i<numVers;i++) { memcpy(&value16, &dataoffs[packet_offset], 2); value16 = ntohs(value16); debug_printf(DEBUG_AUTHTYPES, "AT_VERSION_LIST Value : %d\n", value16); if (value16 > maxver) maxver = value16; packet_offset += 2; } if (maxver > EAPSIM_MAX_SUPPORTED_VER) maxver = EAPSIM_MAX_SUPPORTED_VER; debug_printf(DEBUG_AUTHTYPES, "Setting version to %d\n",maxver); typelenres = (struct typelengthres *)&out[outptr]; typelenres->type = AT_SELECTED_VERSION; typelenres->length = 1; typelenres->reserved = htons(maxver); outptr += sizeof(struct typelengthres); mydata->workingversion = maxver; break; default: debug_printf(DEBUG_NORMAL, "Unknown SIM type!\n"); return XESIMBADTYPE; } } // Write the length in the response header. value16 = htons(outptr); memcpy((char *)&out[1], &value16, 2); *outsize = (outptr); break; case SIM_CHALLENGE: debug_printf(DEBUG_AUTHTYPES, "Got SIM_CHALLENGE!\n"); packet_offset = 3; typelen = (struct typelength *)&out[0]; typelen->type = SIM_CHALLENGE; outptr = 3; while (packet_offset < insize) { switch (dataoffs[packet_offset]) { case AT_RAND: debug_printf(DEBUG_AUTHTYPES, "Got an AT_RAND.\n"); typelenres = (struct typelengthres *)&dataoffs[packet_offset]; packet_offset+=4; memcpy(mydata->triplet[0].random, &dataoffs[packet_offset], 16); debug_printf(DEBUG_AUTHTYPES, "Random1 = "); debug_hex_printf(DEBUG_AUTHTYPES, mydata->triplet[0].random, 16); do_gsm(mydata->triplet[0].random, mydata->triplet[0].response, mydata->triplet[0].ckey); packet_offset+=16; memcpy(mydata->triplet[1].random, &dataoffs[packet_offset], 16); debug_printf(DEBUG_AUTHTYPES, "Random2 = "); debug_hex_printf(DEBUG_AUTHTYPES, mydata->triplet[1].random, 16); do_gsm(mydata->triplet[1].random, mydata->triplet[1].response, mydata->triplet[1].ckey); packet_offset+=16; memcpy(mydata->triplet[2].random, &dataoffs[packet_offset], 16); debug_printf(DEBUG_AUTHTYPES, "Random3 = "); debug_hex_printf(DEBUG_AUTHTYPES, mydata->triplet[2].random, 16); do_gsm(mydata->triplet[2].random, mydata->triplet[2].response, mydata->triplet[2].ckey); packet_offset+=16; if (mydata->workingversion == 0) { hash = (char *)malloc((8*3)+16); // 3 keys + 16 nonce. if (hash == NULL) { debug_printf(DEBUG_NORMAL, "Couldn't allocate memory to build hash!\n"); return XEMALLOC; } bzero(hash, ((8*3)+16)); memcpy(&hash[0], mydata->triplet[0].ckey, 8); memcpy(&hash[8], mydata->triplet[1].ckey, 8); memcpy(&hash[16], mydata->triplet[2].ckey, 8); memcpy(&hash[24], mydata->nonce_mt, 16); SHA1(hash, 40, &sha1resp[0]); } else { tlen = strlen(username)+(8*3)+16+ mydata->verlistlen+2; hash = (char *)malloc(tlen); if (hash == NULL) return XEMALLOC; nsres = (char *)malloc(4*3); if (nsres == NULL) return XEMALLOC; bzero(nsres, 12); memcpy(&nsres[0], mydata->triplet[0].response, 4); memcpy(&nsres[4], mydata->triplet[1].response, 4); memcpy(&nsres[8], mydata->triplet[2].response, 4); bzero(hash, tlen); memcpy(&hash[0], username, strlen(username)); memcpy(&hash[strlen(username)], mydata->triplet[0].ckey, 8); memcpy(&hash[strlen(username)+8], mydata->triplet[1].ckey, 8); memcpy(&hash[strlen(username)+16], mydata->triplet[2].ckey, 8); memcpy(&hash[strlen(username)+24], mydata->nonce_mt, 16); memcpy(&hash[strlen(username)+24+16], mydata->verlist, mydata->verlistlen); value16 = htons(mydata->workingversion); memcpy(&hash[strlen(username)+24+16+ mydata->verlistlen], &value16, 2); SHA1(hash, (strlen(username)+24+16+ mydata->verlistlen+2), sha1resp); free(hash); hash = NULL; } debug_printf(DEBUG_AUTHTYPES, "MK = "); debug_hex_printf(DEBUG_AUTHTYPES, &sha1resp[0], 20); at_mac_sres = (char *)malloc(120); if (at_mac_sres == NULL) { debug_printf(DEBUG_NORMAL, "Couldn't malloc at_mac_sres!\n"); return XEMALLOC; } fips186_2_prng(sha1resp, 20, NULL, 0, at_mac_sres, 120); if (mydata->workingversion == 0) { memcpy(&K_sres[0], &at_mac_sres[0], 16); memcpy(&K_encr[0], &at_mac_sres[16], 16); memcpy(&K_int[0], &at_mac_sres[32], 16); bzero(&K_recv[0], 32); bzero(&K_send[0], 32); memcpy(&K_recv[0], &at_mac_sres[48], 20); memcpy(&K_send[0], &at_mac_sres[68], 20); } else { // K_int is the same as K_aut in Version 1. memcpy(&K_int[0], &at_mac_sres[16], 16); memcpy(&K_recv[0], &at_mac_sres[32], 32); memcpy(&K_send[0], &at_mac_sres[64], 32); } // We should be done with at_mac_sres, so free it. free(at_mac_sres); at_mac_sres = NULL; if (mydata->keyingMaterial != NULL) { free(mydata->keyingMaterial); mydata->keyingMaterial = NULL; } mydata->keyingMaterial = (char *)malloc(64); if (mydata->keyingMaterial == NULL) return XEMALLOC; bzero(mydata->keyingMaterial, 64); memcpy(mydata->keyingMaterial, &K_recv[0], 32); memcpy(&mydata->keyingMaterial[32], &K_send[0], 32); if (mydata->workingversion == 0) { hash = (char *)malloc((4*3)+16); if (hash == NULL) return XEMALLOC; memcpy(&hash[0], mydata->triplet[0].response, 4); memcpy(&hash[4], mydata->triplet[1].response, 4); memcpy(&hash[8], mydata->triplet[2].response, 4); hash[12] = 11; HMAC(EVP_sha1(), &K_sres[0], 16, &hash[0], 13, (char *)&sha1resp[0], &i); debug_printf(DEBUG_AUTHTYPES, "Final return value : "); debug_hex_printf(DEBUG_AUTHTYPES, &sha1resp[0], i); typelenres = (struct typelengthres *)&out[outptr]; typelenres->type = AT_MAC_SRES; typelenres->length = 5; typelenres->reserved = 0; outptr += sizeof(struct typelengthres); memcpy(&out[outptr], &sha1resp, i); outptr += i; } break; case AT_IV: debug_printf(DEBUG_AUTHTYPES, "Got an IV (Not supported)\n"); packet_offset+=5; break; case AT_ENCR_DATA: debug_printf(DEBUG_AUTHTYPES, "Got an AT_ENCR_DATA (Not supported)\n"); packet_offset+=5; break; case AT_MAC: debug_printf(DEBUG_AUTHTYPES, "Got an AT_MAC\n"); saved_offset = packet_offset; memcpy(&mac_val[0], &dataoffs[packet_offset+4], 16); packet_offset+=20; if (mydata->workingversion == 0) { if (do_v0_at_mac(thisint, &K_int[0], dataoffs, insize, saved_offset, &mac_calc[0]) == -1) { debug_printf(DEBUG_NORMAL, "Error calculating AT_MAC for Version 0!\n"); return XESIMBADMAC; } } else { debug_printf(DEBUG_AUTHTYPES, "K_int[0] = "); debug_hex_printf(DEBUG_AUTHTYPES, &K_int[0], 16); if (do_v1_at_mac(thisint, &K_int[0], dataoffs, insize, saved_offset, mydata->nonce_mt, mydata->verlist, mydata->verlistlen, mydata->workingversion, &mac_calc[0]) == -1) { debug_printf(DEBUG_NORMAL, "Error calculating AT_MAC for Version 1!\n"); return XESIMBADMAC; } } if (memcmp(&mac_calc[0], &mac_val[0], 16) != 0) { debug_printf(DEBUG_NORMAL, "ERROR : AT_MAC failed MAC check!\n"); debug_printf(DEBUG_AUTHTYPES, "mac_calc = "); debug_hex_printf(DEBUG_AUTHTYPES, &mac_calc[0], 16); debug_printf(DEBUG_AUTHTYPES, "mac_val = "); debug_hex_printf(DEBUG_AUTHTYPES, &mac_val[0], 16); //return XESIMBADMAC; } } } if (mydata->workingversion == 1) { framecpy = (char *)malloc(outptr+8+20+(8*3)); if (framecpy == NULL) return XEMALLOC; bzero(framecpy, (outptr+5+20+(4*3))); framecpy[0] = 2; framecpy[1] = thisint->eapid; value16 = htons(outptr+5+20); memcpy(&framecpy[2], &value16, 2); framecpy[4] = EAP_TYPE_SIM; memcpy(&framecpy[5], &out[0], outptr); framecpy[5+outptr] = AT_MAC; framecpy[5+outptr+1] = 5; memcpy(&framecpy[5+outptr+20], nsres, (4*3)); debug_printf(DEBUG_AUTHTYPES, "Hashing against :\n"); debug_hex_dump(DEBUG_AUTHTYPES, &framecpy[0], outptr+25+12); HMAC(EVP_sha1(), &K_int[0], 16, framecpy, (outptr+5+20+12), &mac_calc[0], &i); memcpy(&out[outptr], &framecpy[5+outptr], 20); memcpy(&out[outptr+4], &mac_calc[0], 16); outptr += 20; free(framecpy); framecpy = NULL; } if (nsres != NULL) { free(nsres); nsres = NULL; } value16 = htons(outptr); memcpy((char *)&out[1], &value16, 2); *outsize = outptr; break; case SIM_NOTIFICATION: debug_printf(DEBUG_NORMAL, "Got SIM_NOTIFICATION! (Unsupported)\n"); break; case SIM_REAUTHENTICATION: debug_printf(DEBUG_NORMAL, "Got SIM_REAUTHENTICATION! (Unsupported)\n"); break; default: debug_printf(DEBUG_NORMAL, "Unknown SubType value! (%d)\n", dataoffs[0]); break; } out[2] = 0; return XENONE; }
/***************************************************** * * Process OTP EAP Requests * * ******************************************************/ int eapotp_process(struct generic_eap_data *thisint, u_char *dataoffs, int insize, u_char *outframe, int *outsize) { char *otp_chal; char resp[512]; struct config_eap_otp *userdata; debug_printf(DEBUG_EVERYTHING, "(EAP-OTP) Processing.\n"); if ((!thisint) || (!dataoffs) || (!outframe)) { debug_printf(DEBUG_NORMAL, "Invalid paramaters passed to eapotp_process()!\n"); return XEMALLOC; } if (!outsize) { debug_printf(DEBUG_NORMAL, "Invalid pointer to out size in eapotp_process()!\n"); return XEMALLOC; } debug_printf(DEBUG_AUTHTYPES, "OTP/GTC packet dump : \n"); debug_hex_printf(DEBUG_AUTHTYPES, dataoffs, insize); *outsize = 0; userdata = thisint->eap_conf_data; if (!userdata) { debug_printf(DEBUG_NORMAL, "Invalid configuration data in eapotp_process()!\n"); return XENOUSERDATA; } if (thisint->tempPwd == NULL) { otp_chal = (char *)malloc(insize+1); if (otp_chal == NULL) { debug_printf(DEBUG_NORMAL, "Couldn't allocate memory for OTP/GTC challenge!\n"); *outsize = 0; return 0; } bzero(otp_chal, insize+1); memcpy(otp_chal, dataoffs, insize); debug_printf(DEBUG_NORMAL, "Challenge : %s\n",otp_chal); // We need a password. thisint->need_password = 1; thisint->eaptype = strdup("EAP-OTP/GTC"); thisint->eapchallenge = otp_chal; *outsize = 0; return XENONE; } // Make sure we have something to process... if (dataoffs == NULL) return XENONE; /* debug_printf(DEBUG_NORMAL, "Response : "); gets(&resp); */ strcpy(outframe, resp); *outsize = strlen(resp); return *outsize; }
int socketInitializeLLDP(struct lldp_port *lldp_port) { struct ifreq *ifr = malloc(sizeof(struct ifreq)); struct sockaddr_ll *sll = malloc(sizeof(struct sockaddr_ll)); int retval = 0; if(lldp_port->if_name == NULL) { debug_printf(DEBUG_NORMAL, "Got NULL interface in %s():%d\n", __FUNCTION__, __LINE__); return XENOSOCK; } if(lldp_port->if_index <= 0) { debug_printf(DEBUG_NORMAL, "'%s' does not appear to be a valid interface name!\n", lldp_port->if_name); return XENOSOCK; } debug_printf(DEBUG_INT, "'%s' is index %d\n", lldp_port->if_name, lldp_port->if_index); // Set up the raw socket for the LLDP ethertype lldp_port->socket = socket(PF_PACKET, SOCK_RAW, htons(0x88CC)); if(lldp_port->socket < 0) { debug_printf(DEBUG_NORMAL, "Couldn't initialize raw socket for interface %s!\n", lldp_port->if_name); return XENOSOCK; } // Set up the interface for binding sll->sll_family = PF_PACKET; sll->sll_ifindex = lldp_port->if_index; sll->sll_protocol = htons(0x88CC); // Bind the socket and the interface together to form a useable socket: retval = bind(lldp_port->socket, (struct sockaddr *)sll, sizeof(struct sockaddr_ll)); if(retval < 0) { debug_printf(DEBUG_NORMAL, "Error binding raw socket to interface %s in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); return XENOSOCK; } ifr->ifr_ifindex = lldp_port->if_index; strncpy(ifr->ifr_name, &lldp_port->if_name[0], strlen(lldp_port->if_name)); if(strlen(ifr->ifr_name) == 0) { debug_printf(DEBUG_NORMAL, "Invalid interface name in %s():%d\n", __FUNCTION__, __LINE__); return XENOSOCK; } retval = _getmac(lldp_port); if(retval < 0) { debug_printf(DEBUG_NORMAL, "Error getting hardware (MAC) address for interface '%s' in %s():%d - %d:%s!\n", lldp_port->if_name, __FUNCTION__, __LINE__, errno, strerror(errno)); return retval; } debug_printf(DEBUG_INT, "Source MAC is: "); debug_hex_printf(DEBUG_INT, lldp_port->source_mac, 6); retval = _getip(lldp_port); if (retval < 0) { debug_printf(DEBUG_NORMAL, "Error getting interface IP address for interface '%s' in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); } retval = ioctl(lldp_port->socket, SIOCGIFFLAGS, ifr); if (retval == -1) { debug_printf(DEBUG_NORMAL, "Can't get flags for interface '%s' in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); } if ((ifr->ifr_flags & IFF_UP) == 0) { debug_printf(DEBUG_INT, "Interface '%s' is down. portEnabled = 0.\n", lldp_port->if_name); lldp_port->portEnabled = 0; } // set allmulti on interface // need to devise a graceful way to turn off allmulti otherwise it is left on for the interface when problem is terminated. retval = ioctl(lldp_port->socket, SIOCGIFFLAGS, ifr); if (retval == -1) { debug_printf(DEBUG_NORMAL, "Can't get flags for interface '%s' in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); } ifr->ifr_flags |= IFF_ALLMULTI; // allmulti on (verified via ifconfig) // ifr.ifr_flags &= ~IFF_ALLMULTI; // allmulti off (I think) retval = ioctl(lldp_port->socket, SIOCSIFFLAGS, ifr); if (retval == -1) { debug_printf(DEBUG_NORMAL, "Can't set flags for interface '%s' in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); } // Discover MTU of our interface. retval = ioctl(lldp_port->socket, SIOCGIFMTU, ifr); if(retval < 0) { debug_printf(DEBUG_NORMAL, "Can't determine MTU for interface '%s' in %s():%d!\n", lldp_port->if_name, __FUNCTION__, __LINE__); return retval; } lldp_port->mtu = ifr->ifr_ifru.ifru_mtu; debug_printf(DEBUG_INT, "[%s] MTU is %d\n", lldp_port->if_name, lldp_port->mtu); lldp_port->rx.frame = malloc(lldp_port->mtu - 4); lldp_port->tx.frame = malloc((lldp_port->mtu - 2)); if(!lldp_port->rx.frame) { debug_printf(DEBUG_NORMAL, "[ERROR] Unable to malloc buffer in %s() at line: %d!\n", __FUNCTION__, __LINE__); } else { debug_printf(DEBUG_INT, "Created framebuffer for %s at %x\n", lldp_port->if_name, &lldp_port->rx.frame); } if(!lldp_port->tx.frame) { debug_printf(DEBUG_NORMAL, "[ERROR] Unable to malloc buffer in %s() at line: %d!\n", __FUNCTION__, __LINE__); } else { debug_printf(DEBUG_INT, "Created framebuffer for %s at %x\n", lldp_port->if_name, &lldp_port->tx.frame); } debug_printf(DEBUG_INT, "Interface (%s) MTU is %d.\n", lldp_port->if_name, lldp_port->mtu); free(ifr); free(sll); return 0; }