source: trunk/package/libpcap/patches/200-debian_fix_any_intf.patch @ 20057

Last change on this file since 20057 was 20057, checked in by thepeople, 7 years ago

fix missing parts of r19997.

File size: 4.4 KB
  • pcap-linux.c

    a b pcap_create(const char *device, char *eb 
    297297{ 
    298298        pcap_t *handle; 
    299299 
     300        /* 
     301         * A null device name is equivalent to the "any" device. 
     302         */ 
     303        if (device == NULL) 
     304                device = "any"; 
     305 
    300306#ifdef HAVE_DAG_API 
    301307        if (strstr(device, "dag")) { 
    302308                return dag_create(device, ebuf); 
    pcap_can_set_rfmon_linux(pcap_t *p) 
    338344        struct iwreq ireq; 
    339345#endif 
    340346 
    341         if (p->opt.source == NULL) { 
     347        if (strcmp(p->opt.source, "any") == 0) { 
    342348                /* 
    343                  * This is equivalent to the "any" device, and we don't 
    344                  * support monitor mode on it. 
     349                 * Monitor mode makes no sense on the "any" device. 
    345350                 */ 
    346351                return 0; 
    347352        } 
    pcap_activate_linux(pcap_t *handle) 
    518523        handle->stats_op = pcap_stats_linux; 
    519524 
    520525        /* 
    521          * NULL and "any" are special devices which give us the hint to 
    522          * monitor all devices. 
     526         * The "any" device is a special device which causes us not 
     527         * to bind to a particular device and thus to look at all 
     528         * devices. 
    523529         */ 
    524         if (!device || strcmp(device, "any") == 0) { 
    525                 device                  = NULL; 
    526                 handle->md.device       = strdup("any"); 
     530        if (strcmp(device, "any") == 0) { 
    527531                if (handle->opt.promisc) { 
    528532                        handle->opt.promisc = 0; 
    529533                        /* Just a warning. */ 
    pcap_activate_linux(pcap_t *handle) 
    531535                            "Promiscuous mode not supported on the \"any\" device"); 
    532536                        status = PCAP_WARNING_PROMISC_NOTSUP; 
    533537                } 
     538        } 
    534539 
    535         } else 
    536                 handle->md.device       = strdup(device); 
    537  
     540        handle->md.device       = strdup(device); 
    538541        if (handle->md.device == NULL) { 
    539542                snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "strdup: %s", 
    540543                         pcap_strerror(errno) ); 
    static int 
    16571660activate_new(pcap_t *handle) 
    16581661{ 
    16591662#ifdef HAVE_PF_PACKET_SOCKETS 
     1663        const char              *device = handle->opt.source; 
     1664        int                     is_any_device = (strcmp(device, "any") == 0); 
    16601665        int                     sock_fd = -1, arptype, val; 
    16611666        int                     err = 0; 
    16621667        struct packet_mreq      mr; 
    1663         const char* device = handle->opt.source; 
    16641668 
    16651669        /* 
    1666          * Open a socket with protocol family packet. If a device is 
    1667          * given we try to open it in raw mode otherwise we use 
    1668          * the cooked interface. 
    1669          */ 
    1670         sock_fd = device ? 
    1671                 socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)) 
    1672               : socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)); 
     1670         * Open a socket with protocol family packet. If the 
     1671         * "any" device was specified, we open a SOCK_DGRAM 
     1672         * socket for the cooked interface, otherwise we first 
     1673         * try a SOCK_RAW socket for the raw interface. 
     1674         */ 
     1675        sock_fd = is_any_device ? 
     1676                socket(PF_PACKET, SOCK_DGRAM, htons(ETH_P_ALL)) : 
     1677                socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL)); 
    16731678 
    16741679        if (sock_fd == -1) { 
    16751680                snprintf(handle->errbuf, PCAP_ERRBUF_SIZE, "socket: %s", 
    activate_new(pcap_t *handle) 
    17041709         * to cooked mode if we have an unknown interface type 
    17051710         * or a type we know doesn't work well in raw mode. 
    17061711         */ 
    1707         if (device) { 
     1712        if (!is_any_device) { 
    17081713                /* Assume for now we don't need cooked mode. */ 
    17091714                handle->md.cooked = 0; 
    17101715 
    activate_new(pcap_t *handle) 
    18191824                } 
    18201825        } else { 
    18211826                /* 
    1822                  * This is cooked mode. 
     1827                 * The "any" device. 
     1828                 */ 
     1829                if (handle->opt.rfmon) { 
     1830                        /* 
     1831                         * It doesn't support monitor mode. 
     1832                         */ 
     1833                        return PCAP_ERROR_RFMON_NOTSUP; 
     1834                } 
     1835 
     1836                /* 
     1837                 * It uses cooked mode. 
    18231838                 */ 
    18241839                handle->md.cooked = 1; 
    18251840                handle->linktype = DLT_LINUX_SLL; 
    18261841 
    18271842                /* 
    18281843                 * We're not bound to a device. 
    1829                  * XXX - true?  Or true only if we're using 
    1830                  * the "any" device? 
    18311844                 * For now, we're using this as an indication 
    18321845                 * that we can't transmit; stop doing that only 
    18331846                 * if we figure out how to transmit in cooked 
    activate_new(pcap_t *handle) 
    18521865 
    18531866        /* 
    18541867         * Hmm, how can we set promiscuous mode on all interfaces? 
    1855          * I am not sure if that is possible at all. 
     1868         * I am not sure if that is possible at all.  For now, we 
     1869         * silently ignore attempts to turn promiscuous mode on 
     1870         * for the "any" device (so you don't have to explicitly 
     1871         * disable it in programs such as tcpdump). 
    18561872         */ 
    18571873 
    1858         if (device && handle->opt.promisc) { 
     1874        if (!is_any_device && handle->opt.promisc) { 
    18591875                memset(&mr, 0, sizeof(mr)); 
    18601876                mr.mr_ifindex = handle->md.ifindex; 
    18611877                mr.mr_type    = PACKET_MR_PROMISC; 
    activate_old(pcap_t *handle) 
    31183134 
    31193135        /* Bind to the given device */ 
    31203136 
    3121         if (!device) { 
     3137        if (strcmp(device, "any") == 0) { 
    31223138                strncpy(handle->errbuf, "pcap_activate: The \"any\" device isn't supported on 2.0[.x]-kernel systems", 
    31233139                        PCAP_ERRBUF_SIZE); 
    31243140                return PCAP_ERROR; 
Note: See TracBrowser for help on using the repository browser.