开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 网络截获/分析 > 查看源码
ec_inet.c
资源名称：ettercap-0.4.0.tar.gz　[点击查看]
上传用户：nilegod
上传日期：2007-01-08
资源大小：220k
文件大小：17k
源码类别：

网络截获/分析

开发平台：

C/C++

ec_inet.c：源码内容
  1. /*
  2.     ettercap -- inet utilities, arp ping and more...
  4.     Copyright (C) 2001  ALoR <alor@users.sourceforge.net>, NaGA <crwm@freemail.it>
  6.     This program is free software; you can redistribute it and/or modify
  7.     it under the terms of the GNU General Public License as published by
  8.     the Free Software Foundation; either version 2 of the License, or
  9.     (at your option) any later version.
  11.     This program is distributed in the hope that it will be useful,
  12.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.     GNU General Public License for more details.
  16.     You should have received a copy of the GNU General Public License
  17.     along with this program; if not, write to the Free Software
  18.     Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  19. */
  21. #include <stdio.h>
  22. #include <stdlib.h>
  23. #include <unistd.h>
  24. #include <string.h>
  25. #include <sys/time.h>
  26. #include <sys/ioctl.h>
  27. #include <fcntl.h>
  28. #include <signal.h>
  29. #include <errno.h>
  31. #include "include/ec_main.h"
  32. #include "include/ec_error.h"
  33. #include "include/ec_inet_structures.h"
  34. #include "include/ec_inet_forge.h"
  35. #include "include/ec_buffer.h"
  37. #ifdef DEBUG
  38.    #include "include/ec_debug.h"
  39. #endif
  42. char ETH_BROADCAST[6] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
  43. char ARP_BROADCAST[6] = {0x0,0x0,0x0,0x0,0x0,0x0};
  45. typedef struct {
  46.    u_long IP_Add;
  47.    u_char MAC_Add[6];
  48.    struct host_list *next;
  49. } host_list;
  51. struct ifreq old_ifr;       // old iface flags
  52. #ifdef LINUX
  53.    char IpForward_status[2];  // old ipforward status
  54. #else
  55.    int IpForward_status;      // old ipforward status
  56. #endif
  58. // protos...
  60. char * Inet_HostName(char *ip);
  61. char * Inet_NameToIp(char *name);
  62. char * Inet_GetMyInfo(char tipo);
  63. char * Inet_MyIPAddress(void);
  64. char * Inet_MyMACAddress(void);
  65. char * Inet_MySubnet(void);
  66. int Inet_HostInLAN(void);
  67. void Inet_Free_list(host_list *head);
  68. host_list *Inet_Host_in_LAN_list(char *interface);
  69. SniffingHost *Inet_NoSniff(void);
  70. void Inet_PutMACinString(char *mac_string, unsigned char *MAC);
  71. void Inet_GetMACfromString(char *mac_string, unsigned char *MAC);
  72. int Inet_Fake_Host(void);
  73. int Inet_CheckSwitch(void);
  74. // Following are architecture dependent !! implementations are in ./src/`uname`/ec_inet_`uname`.c
  75. int Inet_FindIFace(char *iface);
  76. char Inet_CorrectIface(char *iface);
  77. int Inet_GetIfaceInfo(char *iface, int *MTU, char *MyMAC, u_long *IP, u_long *NetMask);
  78. int Inet_SetPromisc(char *iface);
  79. int Inet_OpenRawSock(char *iface);
  80. int Inet_GetRawPacket(int sock, char *buffer, int MTU, short *type);
  81. int Inet_SendRawPacket(int sock, char *buffer, int len);
  82. void Inet_Restore_ifr(void);
  83. void Inet_DisableForwarding(void);
  84. void Inet_RestoreForwarding(void);
  85. char *Inet_MacFromIP(unsigned long ip);
  86. // ----------------------------------------
  90. #ifdef LINUX
  91.    #include "linux/ec_inet_linux.c"    // Architecture dependent implemetation of Inet functions...
  92. #endif
  94. #ifdef FREEBSD
  95.    #include "BSD/ec_inet_BSD.c"
  96. #endif
  98. #ifdef OPENBSD
  99.    #include "BSD/ec_inet_BSD.c"
  100. #endif
  103. // ----------------------------------------
  106. char * Inet_HostName(char *ip)   // returns hostname from ip
  107. {
  108.    struct hostent *host;
  109.    static struct in_addr addr;
  111.    addr.s_addr = inet_addr(ip);
  112.    host = gethostbyaddr((char *)&addr, sizeof(struct in_addr), AF_INET);
  114.    if (host != NULL) return (char *) host->h_name;
  116.    return "Unknown host";
  117. }
  120. char * Inet_NameToIp(char *name) // returns ip from hostname
  121. {
  122.    struct hostent *host;
  123.    static char ip[16];
  125.    host = gethostbyname(name);
  127.    if (host != NULL)
  128.       strncpy(ip, inet_ntoa( *(struct in_addr *) *host->h_addr_list), 16);
  129.    else
  130.       strncpy(ip, "(null)", 16);
  132.    return ip;
  133. }
  136. char * Inet_GetMyInfo(char tipo)
  137. {
  138.    struct in_addr  to_convert;
  139.    u_long IP_Add, NetMask;
  140.    unsigned char MAC_Add[6];
  141.    static char MAC[18];
  142.    static char MySubnet[16];
  143.    static char IP[16];
  145. #ifdef DEBUG
  146.    switch (tipo)
  147.    {
  148.       case 0: Debug_msg("Inet_GetMyInfo IP"); break;
  149.       case 1: Debug_msg("Inet_GetMyInfo MAC"); break;
  150.       case 2: Debug_msg("Inet_GetMyInfo NetMask"); break;
  151.    }
  152. #endif
  154.    Inet_GetIfaceInfo(Options.netiface, NULL, MAC_Add, &IP_Add, &NetMask);
  157.    switch (tipo)
  158.    {
  159.          case 0:  // requesting IP
  160.                   to_convert.s_addr = IP_Add;
  161.                   sprintf(IP, "%s", inet_ntoa(to_convert));
  162.                   return IP;
  163.                   break;
  165.          case 1:  // requesting MAC
  166.                   Inet_PutMACinString( MAC, MAC_Add );
  167.                   return MAC;
  168.                   break;
  170.          case 2:  // requesting netmask
  171.                   to_convert.s_addr = NetMask;
  172.                   sprintf(MySubnet, "%s", inet_ntoa(to_convert));
  173.                   return MySubnet;
  174.                   break;
  175.    }
  177.    return "(none)";
  179. }
  183. char * Inet_MyIPAddress(void)
  184. {
  185.    return Inet_GetMyInfo(0);
  186. }
  190. char * Inet_MyMACAddress(void)
  191. {
  192.    return Inet_GetMyInfo(1);
  193. }
  197. char * Inet_MySubnet(void)
  198. {
  199.    return Inet_GetMyInfo(2);
  200. }
  203. int Inet_HostInLAN()
  204. {
  205.    host_list *list;
  206.    host_list *index;
  207.    int host_alive = 0, k = 0;
  209. #ifdef DEBUG
  210.    Debug_msg("Inet_HostInLANtIface: %s", Options.netiface);
  211. #endif
  213.    list = Inet_Host_in_LAN_list(Options.netiface);
  215.    index = list;
  217.    for( ; index; host_alive++)
  218.       index = (host_list *)index->next;
  220.    if (Host_In_LAN) free(Host_In_LAN);
  221.    Host_In_LAN = (HOST *)calloc(host_alive,sizeof(HOST));
  222.    if (Host_In_LAN == NULL)
  223.       Error_msg("ec_Inet:%d calloc() | ERRNO : %d | %s", __LINE__, errno, sys_errlist[errno]);
  225.    index = list;
  226.    for( ; index; index = (host_list *)index->next)
  227.    {
  228.       struct in_addr to_convert;
  229.       to_convert.s_addr = index->IP_Add;
  230.       sprintf(Host_In_LAN[k].ip,"%s",inet_ntoa(to_convert));
  231.       snprintf(Host_In_LAN[k].name, 128, "%s", Inet_HostName(Host_In_LAN[k].ip));
  232.       Inet_PutMACinString(Host_In_LAN[k].mac, index->MAC_Add);
  233.       k++;
  234.    }
  235.    Inet_Free_list(list);
  236.    return host_alive;
  237. }
  242. void Inet_Free_list(host_list *head)
  243. {
  244.    if (!head) return;
  246.    Inet_Free_list((host_list *) head->next);
  247.    free(head);
  248. }
  252. host_list *Inet_Host_in_LAN_list(char *interface)
  253. {
  254.    int sock, N_hosts, index, MTU;
  255.    u_long NetMask, BroadAdd;
  256.    host_list *head;
  257.    u_char *buf;
  258.    TIME_DECLARE;
  261. #ifdef DEBUG
  262.    Debug_msg("Inet_HostInLAN_list");
  263. #endif
  265.    head = (host_list *)malloc(sizeof(host_list));
  266.    if (head == NULL)
  267.          Error_msg("ec_Inet:%d malloc() | ERRNO : %d | %s", __LINE__, errno, sys_errlist[errno]);
  269.    head->next = NULL;
  271.    sock = Inet_OpenRawSock(interface);
  273.    Inet_GetIfaceInfo(interface, &MTU, head->MAC_Add, &head->IP_Add, &NetMask);
  275.    if (Options.silent) return head;
  277.    N_hosts = ntohl(~NetMask);
  279. #ifdef DEBUG
  280.    Debug_msg("Inet_HostInLAN_list -- netmask 0x%0x  hosts %d", NetMask, N_hosts);
  281. #endif
  283. if (Options.broadping)
  284. {
  286.    BroadAdd = head->IP_Add | (~NetMask);
  287.     buf = Inet_Forge_packet( ETH_HEADER + IP_HEADER + ICMP_HEADER );
  288.     Inet_Forge_ethernet( buf, head->MAC_Add, ETH_BROADCAST, ETH_P_IP );
  290.     Inet_Forge_ip( buf + ETH_HEADER,
  291.                    head->IP_Add,
  292.                    BroadAdd,
  293.                    sizeof(ICMP_header),
  294.                    0xe77e,
  295.                    0,
  296.                    IPPROTO_ICMP );
  298.     Inet_Forge_icmp( buf + ETH_HEADER + IP_HEADER, ICMP_ECHO, 0, NULL, 0 );
  299.     Inet_SendRawPacket(sock, buf, ETH_HEADER + IP_HEADER + ICMP_HEADER);
  300.     Inet_Forge_packet_destroy( buf );
  302. }
  303. else // !broadping
  304. {
  306.     buf = Inet_Forge_packet( ETH_HEADER + ARP_HEADER );
  308.     // frame ethernet header
  309.     Inet_Forge_ethernet( buf, head->MAC_Add, ETH_BROADCAST, ETH_P_ARP );
  311.     for (index=1; index<=N_hosts; index++)
  312.     {
  313.        int dest_ip;
  314.        dest_ip = (head->IP_Add&NetMask)|htonl(index);
  316.        // if dest is equal to me
  317.        if (dest_ip != head->IP_Add)
  318.        {
  319.           // arp request
  320.           Inet_Forge_arp( buf+ETH_HEADER, ARPOP_REQUEST,
  321.                           head->MAC_Add, head->IP_Add,
  322.                           ARP_BROADCAST, dest_ip );
  324.           Inet_SendRawPacket(sock, buf, ETH_HEADER + ARP_HEADER);
  325.        }
  326.        usleep(500);
  327.     }
  329.     Inet_Forge_packet_destroy( buf );
  331. }
  333. #ifdef DEBUG
  334.    Debug_msg("Inet_HostInLAN_list -- listening for replies...");
  335. #endif
  337.    fcntl(sock, F_SETFL, O_NONBLOCK);
  339.    TIME_START;
  341.    buf = Inet_Forge_packet( MTU );
  343. if (Options.broadping)
  344. {
  345. do
  346.     {
  347.        short pkttype;
  348.        int len;
  349.        host_list **index;
  350.        ETH_header *HEther;
  351.        IP_header *HIP;
  353.        TIME_FINISH;
  355.        len = Inet_GetRawPacket(sock, buf, MTU, &pkttype);
  357.        if (len > 0 && pkttype == PACKET_HOST)
  358.        {
  359.           HEther = (ETH_header *) buf;
  360.           if ( ntohs(HEther->type) == ETH_P_IP )
  361.           {
  362.              HIP = (IP_header *)(HEther + 1);
  363.              if (HIP->proto != IPPROTO_ICMP) continue;
  364.              index = &head;
  366. #ifdef DEBUG
  367.    Debug_msg("Inet_HostInLAN_list -- got a reply after %.5f seconds", TIME_ELAPSED );
  368. #endif
  370.              while(*index != NULL && memcmp(&((*index)->IP_Add),&HIP->source_ip,4))
  371.           index = (host_list **)&((*index)->next);
  373.              if (*index == NULL)
  374.              {
  375.       if ( (*index = (host_list *)malloc(sizeof(host_list))) == NULL)
  376.                     Error_msg("ec_inet:%d malloc() | ERRNO : %d | %s", __LINE__, errno, sys_errlist[errno]);
  377.           (*index)->next = NULL;
  378.           memcpy((*index)->MAC_Add, HEther->source_mac, 6);
  379.           memcpy((char *)&((*index)->IP_Add), &HIP->source_ip, 4);
  380.              }
  381.           }
  382.        }
  383.     } while ( TIME_ELAPSED < 1 );
  385. }
  386. else // !broadping
  387. {
  389.     do
  390.     {
  391.        int leng = 0;
  392.        short pkttype;
  393.        host_list **index;
  394.        ETH_header *ethpkt;
  395.        ARP_header *arppkt;
  397.        leng = Inet_GetRawPacket(sock, buf, MTU, &pkttype);
  399.        ethpkt = (ETH_header *)buf;
  400.        arppkt = (ARP_header *)(buf + ETH_HEADER);
  402.        TIME_FINISH;
  404.        if (leng > 0 && pkttype == PACKET_HOST && ethpkt->type == htons(ETH_P_ARP) && arppkt->opcode == htons(ARPOP_REPLY))
  405.        {
  406.           index = &head;
  408. #ifdef DEBUG
  409.    Debug_msg("Inet_HostInLAN_list -- got a reply after %.5f seconds", TIME_ELAPSED );
  410. #endif
  412.           while(*index != NULL && memcmp(&((*index)->IP_Add),arppkt->source_ip,4))
  413.              index = (host_list **)&((*index)->next);
  415.           if (*index == NULL)
  416.           {
  417.              if ( (*index = (host_list *)malloc(sizeof(host_list))) == NULL)
  418.                 Error_msg("ec_inet:%d malloc() | ERRNO : %d | %s", __LINE__, errno, sys_errlist[errno]);
  419.              (*index)->next = NULL;
  420.              memcpy((*index)->MAC_Add, arppkt->source_add, 6);
  421.              memcpy((char *)&((*index)->IP_Add), arppkt->source_ip, 4);
  422.           }
  423.        }
  424.     } while ( TIME_ELAPSED < 1.5 );
  426. }
  428.    Inet_Forge_packet_destroy( buf );
  429.    close(sock);
  430.    return head;
  431. }
  435. SniffingHost *Inet_NoSniff(void)
  436. {
  437.    static SniffingHost *SniffTable=NULL;
  438.    int i, j, len, sock, MTU, SniffTableIndex=0;
  439.    ETH_header  *HEther;
  440.    IP_header *HIP;
  441.    u_char *buf;
  442.    TIME_DECLARE;
  444. #ifdef DEBUG
  445.    Debug_msg("Inet_NoSniff");
  446. #endif
  448.    if (SniffTable) free (SniffTable);
  449.    SniffTable = calloc(number_of_hosts_in_lan, sizeof(SniffingHost));
  450.    memset(SniffTable,0,sizeof(SniffingHost)*number_of_hosts_in_lan);
  452.    sock = Inet_OpenRawSock(Options.netiface);
  454.    Inet_GetIfaceInfo(Options.netiface, &MTU, NULL, NULL, NULL);
  456.    buf = Inet_Forge_packet( ETH_HEADER + IP_HEADER + ICMP_HEADER );
  458.    for (i=0; i<number_of_hosts_in_lan; i++)
  459.    {
  460.       if (inet_addr(Inet_MyIPAddress()) != inet_addr(Host_In_LAN[i].ip))
  461.       {
  462.          char MyMAC[6];
  463.          char DestMAC[6];
  465.          Inet_GetMACfromString(Host_In_LAN[0].mac, MyMAC);
  466.          Inet_GetMACfromString(Host_In_LAN[i].mac, DestMAC);
  468.          Inet_Forge_ethernet( buf, MyMAC, DestMAC, ETH_P_IP );
  470.          Inet_Forge_ip( buf + ETH_HEADER,
  471.                         inet_addr(Host_In_LAN[0].ip),
  472.                         inet_addr(Host_In_LAN[i].ip),
  473.                         sizeof(ICMP_header),
  474.                         0xe77e,
  475.                         0,
  476.                         IPPROTO_ICMP );
  478.          Inet_Forge_icmp( buf + ETH_HEADER + IP_HEADER, ICMP_ECHO, 0, NULL, 0 );
  480.          Inet_SendRawPacket(sock, buf, ETH_HEADER + IP_HEADER + ICMP_HEADER);
  481.          usleep(1000);
  482.       }
  483.    }
  485.    Inet_Forge_packet_destroy( buf );
  487. #ifdef DEBUG
  488.    Debug_msg("Inet_NoSniff -- after ICMP storm");
  489. #endif
  491.    buf = Inet_Forge_packet( MTU );
  493.    fcntl(sock, F_SETFL, O_NONBLOCK);
  495.    TIME_START;
  497.    // Search for strange replies
  498.    do
  499.    {
  500.       short pkttype;
  502.       TIME_FINISH;
  504.       len = Inet_GetRawPacket(sock, buf, MTU, &pkttype);
  506.       if (len > 0 && pkttype == PACKET_HOST)
  507.       {
  508.          HEther = (ETH_header *) buf;
  509.          if ( ntohs(HEther->type) == ETH_P_IP )
  510.          {
  511.             unsigned char MACS[20];
  512.             HIP = (IP_header *)(HEther + 1);
  513.             Inet_PutMACinString(MACS, HEther->source_mac);
  515.             if (HIP->proto != IPPROTO_ICMP) continue;
  517. #ifdef DEBUG
  518.    Debug_msg("Inet_NoSniff -- got a ICMP reply after %.5f seconds", TIME_ELAPSED );
  519. #endif
  521.             for(i=0; i<number_of_hosts_in_lan; i++)
  522.             {
  523.                if ( inet_addr(Host_In_LAN[i].ip ) == HIP->source_ip )
  524.                {
  525.                   if (memcmp(MACS,Host_In_LAN[i].mac,17))
  526.                   {
  527.                      for (j=0; j<number_of_hosts_in_lan; j++)
  528.                         if (!memcmp(MACS, Host_In_LAN[j].mac, 17)) break;
  530.                      SniffTable[SniffTableIndex].Host_Index1=j;
  531.                      SniffTable[SniffTableIndex].Host_Index2=i;
  532.                      SniffTable[SniffTableIndex].mode=1;
  533.                      SniffTableIndex++;
  534.                      break;
  535.                   }
  536.                }
  537.             }
  538.          }
  539.       }
  540.    } while ( TIME_ELAPSED < 3 );
  542.    // Search for strange ARP entries
  543.    for (i=0; i<number_of_hosts_in_lan-1; i++)
  544.       for(j=i+1; j<number_of_hosts_in_lan; j++)
  545.          if (!memcmp(Host_In_LAN[i].mac, Host_In_LAN[j].mac, 17))
  546.          {
  547.             SniffTable[SniffTableIndex].Host_Index1=i;
  548.             SniffTable[SniffTableIndex].Host_Index2=j;
  549.             SniffTable[SniffTableIndex].mode=2;
  550.             SniffTableIndex++;
  551.          }
  553.    Inet_Forge_packet_destroy( buf );
  555.    close(sock);
  556.    return (SniffTable);
  557. }
  560. int Inet_Fake_Host()
  561. {
  562.    unsigned int N_hosts, index, index1=0, index2, base_ip, fake_ip=0;
  563.    unsigned long NetMask;
  565.    Inet_GetIfaceInfo(Options.netiface, NULL, NULL, NULL, &NetMask);
  566.    N_hosts = ntohl(~NetMask);
  568.    base_ip = inet_addr(Host_In_LAN[0].ip)&NetMask;
  570.    for (index=1; index<N_hosts; index++)
  571.    {
  572.       fake_ip = base_ip|htonl(index);
  573.       for (index2=0; index2 < number_of_hosts_in_lan; index2++)
  574.          if (fake_ip == inet_addr(Host_In_LAN[index2].ip))
  575.             break;
  576.       if (index2 == number_of_hosts_in_lan) break;
  577.    }
  579.    if (index1 == N_hosts) return 0;
  581.    return (fake_ip);
  582. }
  585. // 0 - Unknown
  586. // 1 - Hub
  587. // 2 - Switch
  588. int Inet_CheckSwitch()
  589. {
  590.    int link_type=2;
  591.    if (number_of_hosts_in_lan>1)
  592.    {
  593.        int fakeip,destip,sock,MTU,i;
  594.        char MyMAC[6],DestMAC[6];
  595.        char *buf;
  596.        TIME_DECLARE;
  598.        fakeip=Inet_Fake_Host();
  599.        destip=inet_addr(Host_In_LAN[1].ip);
  600.        Inet_GetMACfromString(Host_In_LAN[1].mac, DestMAC);
  601.        sock = Inet_OpenRawSock(Options.netiface);
  602.        fcntl(sock, F_SETFL, O_NONBLOCK);
  603.        Inet_GetIfaceInfo(Options.netiface, &MTU, MyMAC, NULL, NULL);
  604.        Inet_SetPromisc(Options.netiface);
  606.        buf = Inet_Forge_packet(MTU);
  607.        Inet_Forge_ethernet( buf, MyMAC, DestMAC, ETH_P_IP );
  608.        Inet_Forge_ip( buf + ETH_HEADER,
  609.                       fakeip, destip,
  610.                       sizeof(ICMP_header),
  611.                       0xe77e, 0,
  612.                       IPPROTO_ICMP );
  613.        Inet_Forge_icmp( buf + ETH_HEADER + IP_HEADER, ICMP_ECHO, 0, NULL, 0 );
  614.        Inet_SendRawPacket(sock, buf, ETH_HEADER + IP_HEADER + ICMP_HEADER);
  616.        Inet_Forge_ethernet( buf, MyMAC, DestMAC, ETH_P_ARP );
  617.        Inet_Forge_arp( buf+ETH_HEADER, ARPOP_REPLY,
  618.                       DestMAC, fakeip,
  619.                       DestMAC, destip );
  620.        for(i=0; i<5; i++)
  621.        {
  622.            usleep(1000);
  623.            Inet_SendRawPacket(sock, buf, ETH_HEADER + ARP_HEADER);
  624.        }
  626.        TIME_START;
  627.        do
  628.        {
  629.            short type; int len;
  631.            len=Inet_GetRawPacket(sock,buf,MTU,&type);
  632.            TIME_FINISH;
  634.     if (len>0)
  635.     {
  636.         ETH_header *eth;
  637.         eth=(ETH_header *)buf;
  638.         if (!memcmp(DestMAC,eth->dest_mac,6))
  639.         {
  640.        link_type=1;
  641.     break;
  642.         }
  643.     }
  644. }while(TIME_ELAPSED<1);
  646.        free(buf);
  647.        close(sock);
  648.    }
  649.    else return 0;
  650.    Inet_Restore_ifr();
  651.    return link_type;
  652. }
  656. void Inet_GetMACfromString(char *mac_string, unsigned char *MAC)
  657. {
  658.    unsigned int MAC_Add[6];
  659.    int i;
  661.    memset(&MAC_Add, 0, 6);
  663.    i = sscanf(mac_string,"%02X:%02X:%02X:%02X:%02X:%02X",
  664.       (unsigned int *)&MAC_Add[0],(unsigned int *)&MAC_Add[1],(unsigned int *)&MAC_Add[2],
  665.       (unsigned int *)&MAC_Add[3],(unsigned int *)&MAC_Add[4],(unsigned int *)&MAC_Add[5]);
  667.    if (i == 0)
  668.       Error_msg("Incorrect parsing of MAC [%s] !!nIt must be in the form 01:02:03:04:05:06 !!", mac_string);
  670.    for (i=0; i<6; i++)
  671.       MAC[i]=(unsigned char)MAC_Add[i];
  672. }
  676. void Inet_PutMACinString(char *mac_string, unsigned char *MAC)
  677. {
  678.    unsigned int MAC_Add[6];
  679.    int i;
  681.    for (i=0; i<6; i++)
  682.       MAC_Add[i]=(unsigned int)MAC[i];
  684.    sprintf(mac_string,"%02X:%02X:%02X:%02X:%02X:%02X",
  685.       (unsigned int)MAC_Add[0],(unsigned int)MAC_Add[1],(unsigned int)MAC_Add[2],
  686.       (unsigned int)MAC_Add[3],(unsigned int)MAC_Add[4],(unsigned int)MAC_Add[5]);
  688. }
  690. /* EOF */