/* * Create new entry (from uspace) */ static int ip_masq_user_new(struct ip_masq_user *ums) { struct ip_masq *ms = NULL; unsigned mflags = 0; int ret; if (masq_proto_num (ums->protocol) == -1) { return EPROTONOSUPPORT; } if (ums->dport == 0) { ums->flags |= IP_MASQ_USER_F_LISTEN; } if (ums->flags | IP_MASQ_USER_F_LISTEN) { if ((ums->saddr == 0) || (ums->sport == 0)) { return EINVAL; } mflags |= (IP_MASQ_F_NO_DPORT|IP_MASQ_F_NO_DADDR); } if ((ret = ip_masq_user_maddr(ums)) < 0) { return -ret; } mflags |= IP_MASQ_F_USER; ms = ip_masq_new(ums->protocol, ums->maddr, ums->mport, ums->saddr, ums->sport, ums->daddr, ums->dport, mflags); if (ms == NULL) { /* * FIXME: ip_masq_new() should return errno */ return EBUSY; } /* * Setup timeouts for this new entry */ if (ums->timeout) { ms->timeout = ums->timeout; } else if (ums->flags | IP_MASQ_USER_F_LISTEN) { ip_masq_listen(ms); } masq_user_k2u(ms, ums); ip_masq_put(ms); return 0; }
int masq_vdolive_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *data, *data_limit; unsigned int tagval; /* This should be a 32 bit quantity */ struct ip_masq *n_ms; struct vdolive_priv_data *priv = (struct vdolive_priv_data *)ms->app_data; /* This doesn't work at all if no priv data was allocated on startup */ if (!priv) return 0; /* Everything running correctly already */ if (priv->state == 3) return 0; skb = *skb_p; iph = skb->h.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; data_limit = skb->h.raw + skb->len; if (data+8 > data_limit) { #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: packet too short for ID %lx %lx\n", data, data_limit); #endif return 0; } memcpy(&tagval, data+4, 4); #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: packet seen, tag %ld, in initial state %d\n", ntohl(tagval), priv->state); #endif /* Check for leading packet ID */ if ((ntohl(tagval) != 6) && (ntohl(tagval) != 1)) { #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: unrecognised tag %ld, in initial state %d\n", ntohl(tagval), priv->state); #endif return 0; } /* Check packet is long enough for data - ignore if not */ if ((ntohl(tagval) == 6) && (data+36 > data_limit)) { #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: initial packet too short %lx %lx\n", data, data_limit); #endif return 0; } else if ((ntohl(tagval) == 1) && (data+20 > data_limit)) { #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: secondary packet too short %lx %lx\n", data, data_limit); #endif return 0; } /* Adjust data pointers */ /* * I could check the complete protocol version tag * in here however I am just going to look for the * "VDO Live" tag in the hope that this part will * remain constant even if the version changes */ if (ntohl(tagval) == 6) { data += 24; #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: initial packet found\n"); #endif } else { data += 8; #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: secondary packet found\n"); #endif } if (memcmp(data, "VDO Live", 8) != 0) { #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: did not find tag\n"); #endif return 0; } /* * The port number is the next word after the tag. * VDOlive encodes all of these values * in 32 bit words, so in this case I am * skipping the first 2 bytes of the next * word to get to the relevant 16 bits */ data += 10; /* * If we have not seen the port already, * set the masquerading tunnel up */ if (!priv->origport) { memcpy(&priv->origport, data, 2); #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: found port %d\n", ntohs(priv->origport)); #endif /* Open up a tunnel */ n_ms = ip_masq_new(dev, IPPROTO_UDP, ms->saddr, priv->origport, ms->daddr, 0, IP_MASQ_F_NO_DPORT); if (n_ms==NULL) { printk("VDOlive: unable to build UDP tunnel for %x:%x\n", ms->saddr, priv->origport); /* Leave state as unset */ priv->origport = 0; return 0; } ip_masq_set_expire(n_ms, ip_masq_expire->udp_timeout); priv->masqport = n_ms->mport; } else if (memcmp(data, &(priv->origport), 2)) { printk("VDOlive: ports do not match\n"); /* Write the port in anyhow!!! */ } /* * Write masq port into packet */ memcpy(data, &(priv->masqport), 2); #if DEBUG_CONFIG_IP_MASQ_VDOLIVE printk("VDOlive: rewrote port %d to %d, server %s\n", ntohs(priv->origport), ntohs(priv->masqport), in_ntoa(ms->saddr)); #endif /* * Set state bit to make which bit has been done */ priv->state |= (ntohl(tagval) == 6) ? 1 : 2; return 0; }
int masq_irc_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *data, *data_limit; __u32 s_addr; __u16 s_port; struct ip_masq *n_ms; char buf[20]; /* "m_addr m_port" (dec base)*/ unsigned buf_len; int diff; int xtra_args = 0; /* extra int args wanted after addr */ char *dcc_p, *addr_beg_p, *addr_end_p; skb = *skb_p; iph = skb->h.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; /* * Hunt irc DCC string, the _shortest_: * * strlen("DCC CHAT chat AAAAAAAA P\x01\n")=26 * strlen("DCC SEND F AAAAAAAA P S\x01\n")=25 * AAAAAAAAA: bound addr (1.0.0.0==16777216, min 8 digits) * P: bound port (min 1 d ) * F: filename (min 1 d ) * S: size (min 1 d ) * 0x01, \n: terminators */ data_limit = skb->h.raw + skb->len; while (data < (data_limit - 25) ) { if (memcmp(data,"DCC ",4)) { data ++; continue; } dcc_p = data; data += 4; /* point to DCC cmd */ if (memcmp(data, "CHAT ", 5) == 0 || memcmp(data, "SEND ", 5) == 0) { /* * extra arg (file_size) req. for "SEND" */ if (*data == 'S') xtra_args++; data += 5; } else continue; /* * skip next string. */ while( *data++ != ' ') /* * must still parse, at least, "AAAAAAAA P\x01\n", * 12 bytes left. */ if (data > (data_limit-12)) return 0; addr_beg_p = data; /* * client bound address in dec base */ s_addr = simple_strtoul(data,&data,10); if (*data++ !=' ') continue; /* * client bound port in dec base */ s_port = simple_strtoul(data,&data,10); addr_end_p = data; /* * should check args consistency? */ while(xtra_args) { if (*data != ' ') break; data++; simple_strtoul(data,&data,10); xtra_args--; } if (xtra_args != 0) continue; /* * terminators. */ if (data[0] != 0x01) continue; if (data[1]!='\r' && data[1]!='\n') continue; /* * Now create an masquerade entry for it * must set NO_DPORT and NO_DADDR because * connection is requested by another client. */ n_ms = ip_masq_new(dev, IPPROTO_TCP, htonl(s_addr),htons(s_port), 0, 0, IP_MASQ_F_NO_DPORT|IP_MASQ_F_NO_DADDR ); if (n_ms==NULL) return 0; ip_masq_set_expire(n_ms, ip_masq_expire->tcp_fin_timeout); /* * Replace the old "address port" with the new one */ buf_len = sprintf(buf,"%lu %u", ntohl(n_ms->maddr),ntohs(n_ms->mport)); /* * Calculate required delta-offset to keep TCP happy */ diff = buf_len - (addr_end_p-addr_beg_p); #if DEBUG_CONFIG_IP_MASQ_IRC *addr_beg_p = '\0'; printk("masq_irc_out(): '%s' %X:%X detected (diff=%d)\n", dcc_p, s_addr,s_port, diff); #endif /* * No shift. */ if (diff==0) { /* * simple case, just copy. */ memcpy(addr_beg_p,buf,buf_len); return 0; } *skb_p = ip_masq_skb_replace(skb, GFP_ATOMIC, addr_beg_p, addr_end_p-addr_beg_p, buf, buf_len); return diff; } return 0; }
int ip_fw_masq_icmp(struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb = *skb_p; struct iphdr *iph = skb->h.iph; struct icmphdr *icmph = (struct icmphdr *)((char *)iph + (iph->ihl<<2)); struct iphdr *ciph; /* The ip header contained within the ICMP */ __u16 *pptr; /* port numbers from TCP/UDP contained header */ struct ip_masq *ms; unsigned short len = ntohs(iph->tot_len) - (iph->ihl * 4); #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("Incoming forward ICMP (%d,%d) %lX -> %lX\n", icmph->type, ntohs(icmp_id(icmph)), ntohl(iph->saddr), ntohl(iph->daddr)); #endif #ifdef CONFIG_IP_MASQUERADE_ICMP if ((icmph->type == ICMP_ECHO ) || (icmph->type == ICMP_TIMESTAMP ) || (icmph->type == ICMP_INFO_REQUEST ) || (icmph->type == ICMP_ADDRESS )) { #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("MASQ: icmp request rcv %lX->%lX id %d type %d\n", ntohl(iph->saddr), ntohl(iph->daddr), ntohs(icmp_id(icmph)), icmph->type); #endif ms = ip_masq_out_get_2(iph->protocol, iph->saddr, icmp_id(icmph), iph->daddr, icmp_hv_req(icmph)); if (ms == NULL) { ms = ip_masq_new(dev, iph->protocol, iph->saddr, icmp_id(icmph), iph->daddr, icmp_hv_req(icmph), 0); if (ms == NULL) return (-1); #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("MASQ: Create new icmp entry\n"); #endif } ip_masq_set_expire(ms, 0); /* Rewrite source address */ /* * If sysctl !=0 and no pkt has been received yet * in this tunnel and routing iface address has changed... * "You are welcome, diald". */ if ( sysctl_ip_dynaddr && ms->flags & IP_MASQ_F_NO_REPLY && dev->pa_addr != ms->maddr) { unsigned long flags; #ifdef DEBUG_CONFIG_IP_MASQUERADE printk(KERN_INFO "ip_fw_masq_icmp(): change masq.addr %s", in_ntoa(ms->maddr)); printk("-> %s\n", in_ntoa(dev->pa_addr)); #endif save_flags(flags); cli(); ip_masq_unhash(ms); ms->maddr = dev->pa_addr; ip_masq_hash(ms); restore_flags(flags); } iph->saddr = ms->maddr; ip_send_check(iph); /* Rewrite port (id) */ (icmph->un).echo.id = ms->mport; icmph->checksum = 0; icmph->checksum = ip_compute_csum((unsigned char *)icmph, len); ip_masq_set_expire(ms, MASQUERADE_EXPIRE_ICMP); #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("MASQ: icmp request rwt %lX->%lX id %d type %d\n", ntohl(iph->saddr), ntohl(iph->daddr), ntohs(icmp_id(icmph)), icmph->type); #endif return (1); } #endif /* * Work through seeing if this is for us. * These checks are supposed to be in an order that * means easy things are checked first to speed up * processing.... however this means that some * packets will manage to get a long way down this * stack and then be rejected, but thats life */ if ((icmph->type != ICMP_DEST_UNREACH) && (icmph->type != ICMP_SOURCE_QUENCH) && (icmph->type != ICMP_TIME_EXCEEDED)) return 0; /* Now find the contained IP header */ ciph = (struct iphdr *) (icmph + 1); #ifdef CONFIG_IP_MASQUERADE_ICMP if (ciph->protocol == IPPROTO_ICMP) { /* * This section handles ICMP errors for ICMP packets */ struct icmphdr *cicmph = (struct icmphdr *)((char *)ciph + (ciph->ihl<<2)); #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("MASQ: fw icmp/icmp rcv %lX->%lX id %d type %d\n", ntohl(ciph->saddr), ntohl(ciph->daddr), ntohs(icmp_id(cicmph)), cicmph->type); #endif ms = ip_masq_out_get_2(ciph->protocol, ciph->daddr, icmp_id(cicmph), ciph->saddr, icmp_hv_rep(cicmph)); if (ms == NULL) return 0; /* Now we do real damage to this packet...! */ /* First change the source IP address, and recalc checksum */ iph->saddr = ms->maddr; ip_send_check(iph); /* Now change the *dest* address in the contained IP */ ciph->daddr = ms->maddr; ip_send_check(ciph); /* Change the ID to the masqed one! */ (cicmph->un).echo.id = ms->mport; /* And finally the ICMP checksum */ icmph->checksum = 0; icmph->checksum = ip_compute_csum((unsigned char *) icmph, len); #ifdef DEBUG_CONFIG_IP_MASQUERADE_ICMP printk("MASQ: fw icmp/icmp rwt %lX->%lX id %d type %d\n", ntohl(ciph->saddr), ntohl(ciph->daddr), ntohs(icmp_id(cicmph)), cicmph->type); #endif return 1; } #endif /* CONFIG_IP_MASQUERADE_ICMP */ /* We are only interested ICMPs generated from TCP or UDP packets */ if ((ciph->protocol != IPPROTO_UDP) && (ciph->protocol != IPPROTO_TCP)) return 0; /* * Find the ports involved - this packet was * incoming so the ports are right way round * (but reversed relative to outer IP header!) */ pptr = (__u16 *)&(((char *)ciph)[ciph->ihl*4]); /* Ensure the checksum is correct */ if (ip_compute_csum((unsigned char *) icmph, len)) { /* Failed checksum! */ printk(KERN_DEBUG "MASQ: forward ICMP: failed checksum from %s!\n", in_ntoa(iph->saddr)); return(-1); } #ifdef DEBUG_CONFIG_IP_MASQUERADE printk("Handling forward ICMP for %lX:%X -> %lX:%X\n", ntohl(ciph->saddr), ntohs(pptr[0]), ntohl(ciph->daddr), ntohs(pptr[1])); #endif /* This is pretty much what ip_masq_out_get() does */ ms = ip_masq_out_get_2(ciph->protocol, ciph->daddr, pptr[1], ciph->saddr, pptr[0]); if (ms == NULL) return 0; /* Now we do real damage to this packet...! */ /* First change the source IP address, and recalc checksum */ iph->saddr = ms->maddr; ip_send_check(iph); /* Now change the *dest* address in the contained IP */ ciph->daddr = ms->maddr; ip_send_check(ciph); /* the TCP/UDP dest port - cannot redo check */ pptr[1] = ms->mport; /* And finally the ICMP checksum */ icmph->checksum = 0; icmph->checksum = ip_compute_csum((unsigned char *) icmph, len); #ifdef DEBUG_CONFIG_IP_MASQUERADE printk("Rewrote forward ICMP to %lX:%X -> %lX:%X\n", ntohl(ciph->saddr), ntohs(pptr[0]), ntohl(ciph->daddr), ntohs(pptr[1])); #endif return 1; }
int masq_quake_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb; struct iphdr *iph; struct udphdr *uh; QUAKEHEADER *qh; __u16 udp_port; char *data; unsigned char code; struct ip_masq *n_ms; struct quake_priv_data *priv = (struct quake_priv_data *)ms->app_data; if(priv->cl_connect == -1) return 0; skb = *skb_p; iph = skb->h.iph; /* iph = skb->nh.iph; */ uh = (struct udphdr *)&(((char *)iph)[iph->ihl*4]); /* Check for lenght */ if(ntohs(uh->len) < 5) return 0; qh = (QUAKEHEADER *)&uh[1]; #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: qh->type = %d \n", (int)qh->type); #endif if(qh->type != 0x0080) return 0; code = qh->message[0]; #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: code = %d \n", (int)code); #endif switch(code) { case 0x01: /* Connection Request */ if(ntohs(qh->length) < 0x0c) { #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: length < 0xc \n"); #endif return 0; } data = &qh->message[1]; /* Check for stomping string */ if(memcmp(data,"QUAKE\0\3",7)) { #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: memcmp failed \n"); #endif return 0; } else { priv->cl_connect = 1; #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: memcmp ok \n"); #endif } break; case 0x81: /* Maybe a redirection of a quake-server at the inner side works in the future? */ /* Accept Connection */ if((ntohs(qh->length) < 0x09) || (priv->cl_connect == 0)) return 0; data = &qh->message[1]; memcpy(&udp_port, data, 2); n_ms = ip_masq_new(dev, IPPROTO_UDP, ms->saddr, htons(udp_port), ms->daddr, ms->dport, 0); if (n_ms==NULL) return 0; #if DEBUG_CONFIG_IP_MASQ_QUAKE printk("Quake_out: out_rewrote UDP port %d -> %d\n", udp_port, ntohs(n_ms->mport)); #endif udp_port = ntohs(n_ms->mport); memcpy(data, &udp_port, 2); break; } return 0; }
int masq_ftp_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *p, *data, *data_limit; unsigned char p1,p2,p3,p4,p5,p6; __u32 from; __u16 port; struct ip_masq *n_ms; char buf[24]; /* xxx.xxx.xxx.xxx,ppp,ppp\000 */ unsigned buf_len; int diff; skb = *skb_p; iph = skb->nh.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; data_limit = skb->h.raw + skb->len - 18; if (skb->len >= 6 && (memcmp(data, "PASV\r\n", 6) == 0 || memcmp(data, "pasv\r\n", 6) == 0)) ms->app_data = &masq_ftp_pasv; while (data < data_limit) { if (memcmp(data,"PORT ",5) && memcmp(data,"port ",5)) { data ++; continue; } p = data+5; p1 = simple_strtoul(data+5,&data,10); if (*data!=',') continue; p2 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p3 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p4 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p5 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p6 = simple_strtoul(data+1,&data,10); if (*data!='\r' && *data!='\n') continue; from = (p1<<24) | (p2<<16) | (p3<<8) | p4; port = (p5<<8) | p6; IP_MASQ_DEBUG(1-debug, "PORT %X:%X detected\n",from,port); /* * Now update or create an masquerade entry for it */ IP_MASQ_DEBUG(1-debug, "protocol %d %lX:%X %X:%X\n", iph->protocol, htonl(from), htons(port), iph->daddr, 0); n_ms = ip_masq_out_get(iph->protocol, htonl(from), htons(port), iph->daddr, 0); if (!n_ms) { n_ms = ip_masq_new(IPPROTO_TCP, maddr, 0, htonl(from), htons(port), iph->daddr, 0, IP_MASQ_F_NO_DPORT); if (n_ms==NULL) return 0; ip_masq_control_add(n_ms, ms); } /* * Replace the old PORT with the new one */ from = ntohl(n_ms->maddr); port = ntohs(n_ms->mport); sprintf(buf,"%d,%d,%d,%d,%d,%d", from>>24&255,from>>16&255,from>>8&255,from&255, port>>8&255,port&255); buf_len = strlen(buf); IP_MASQ_DEBUG(1-debug, "new PORT %X:%X\n",from,port); /* * Calculate required delta-offset to keep TCP happy */ diff = buf_len - (data-p); /* * No shift. */ if (diff==0) { /* * simple case, just replace the old PORT cmd */ memcpy(p,buf,buf_len); } else { *skb_p = ip_masq_skb_replace(skb, GFP_ATOMIC, p, data-p, buf, buf_len); } /* * Move tunnel to listen state */ ip_masq_listen(n_ms); ip_masq_put(n_ms); return diff; } return 0; }
int masq_ftp_in (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *data, *data_limit; unsigned char p1,p2,p3,p4,p5,p6; __u32 to; __u16 port; struct ip_masq *n_ms; if (ms->app_data != &masq_ftp_pasv) return 0; /* quick exit if no outstanding PASV */ skb = *skb_p; iph = skb->nh.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; data_limit = skb->h.raw + skb->len; while (data < data_limit && *data != ' ') ++data; while (data < data_limit && *data == ' ') ++data; data += 22; if (data >= data_limit || *data != '(') return 0; p1 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p2 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p3 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p4 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p5 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p6 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ')') return 0; to = (p1<<24) | (p2<<16) | (p3<<8) | p4; port = (p5<<8) | p6; /* * Now update or create an masquerade entry for it */ IP_MASQ_DEBUG(1-debug, "PASV response %lX:%X %X:%X detected\n", ntohl(ms->saddr), 0, to, port); n_ms = ip_masq_out_get(iph->protocol, ms->saddr, 0, htonl(to), htons(port)); if (!n_ms) { n_ms = ip_masq_new(IPPROTO_TCP, maddr, 0, ms->saddr, 0, htonl(to), htons(port), IP_MASQ_F_NO_SPORT); if (n_ms==NULL) return 0; ip_masq_control_add(n_ms, ms); } #if 0 /* v0.12 state processing */ /* * keep for a bit longer than tcp_fin, client may not issue open * to server port before tcp_fin_timeout. */ n_ms->timeout = ip_masq_expire->tcp_fin_timeout*3; #endif ms->app_data = NULL; ip_masq_put(n_ms); return 0; /* no diff required for incoming packets, thank goodness */ }
int masq_ftp_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *p, *data, *data_limit; unsigned char p1,p2,p3,p4,p5,p6; __u32 from; __u16 port; struct ip_masq *n_ms; char buf[24]; /* xxx.xxx.xxx.xxx,ppp,ppp\000 */ unsigned buf_len; int diff; skb = *skb_p; iph = skb->h.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; data_limit = skb->h.raw + skb->len - 18; if (skb->len >= 6 && (memcmp(data, "PASV\r\n", 6) == 0 || memcmp(data, "pasv\r\n", 6) == 0)) ms->flags |= IP_MASQ_F_FTP_PASV; while (data < data_limit) { if (memcmp(data,"PORT ",5) && memcmp(data,"port ",5)) { data ++; continue; } p = data+5; p1 = simple_strtoul(data+5,&data,10); if (*data!=',') continue; p2 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p3 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p4 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p5 = simple_strtoul(data+1,&data,10); if (*data!=',') continue; p6 = simple_strtoul(data+1,&data,10); if (*data!='\r' && *data!='\n') continue; from = (p1<<24) | (p2<<16) | (p3<<8) | p4; port = (p5<<8) | p6; #if DEBUG_CONFIG_IP_MASQ_FTP printk("PORT %X:%X detected\n",from,port); #endif /* * Now update or create an masquerade entry for it */ #if DEBUG_CONFIG_IP_MASQ_FTP printk("protocol %d %lX:%X %X:%X\n", iph->protocol, htonl(from), htons(port), iph->daddr, 0); #endif n_ms = ip_masq_out_get_2(iph->protocol, htonl(from), htons(port), iph->daddr, 0); if (n_ms) { /* existing masquerade, clear timer */ ip_masq_set_expire(n_ms,0); } else { n_ms = ip_masq_new(dev, IPPROTO_TCP, htonl(from), htons(port), iph->daddr, 0, IP_MASQ_F_NO_DPORT); if (n_ms==NULL) return 0; n_ms->control = ms; /* keepalive from data to the control channel */ ms->flags |= IP_MASQ_F_CONTROL; /* this is a control channel */ } /* * keep for a bit longer than tcp_fin, caller may not reissue * PORT before tcp_fin_timeout. */ ip_masq_set_expire(n_ms, ip_masq_expire->tcp_fin_timeout*3); /* * Replace the old PORT with the new one */ from = ntohl(n_ms->maddr); port = ntohs(n_ms->mport); sprintf(buf,"%d,%d,%d,%d,%d,%d", from>>24&255,from>>16&255,from>>8&255,from&255, port>>8&255,port&255); buf_len = strlen(buf); #if DEBUG_CONFIG_IP_MASQ_FTP printk("new PORT %X:%X\n",from,port); #endif /* * Calculate required delta-offset to keep TCP happy */ diff = buf_len - (data-p); /* * No shift. */ if (diff==0) { /* * simple case, just replace the old PORT cmd */ memcpy(p,buf,buf_len); return 0; } *skb_p = ip_masq_skb_replace(skb, GFP_ATOMIC, p, data-p, buf, buf_len); return diff; } return 0; }
int masq_ftp_in (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, struct device *dev) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *data, *data_limit; unsigned char p1,p2,p3,p4,p5,p6; __u32 to; __u16 port; struct ip_masq *n_ms; if (! ms->flags & IP_MASQ_F_FTP_PASV) return 0; /* quick exit if no outstanding PASV */ skb = *skb_p; iph = skb->h.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; data_limit = skb->h.raw + skb->len; while (data < data_limit && *data != ' ') ++data; while (data < data_limit && *data == ' ') ++data; data += 22; if (data >= data_limit || *data != '(') return 0; p1 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p2 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p3 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p4 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p5 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ',') return 0; p6 = simple_strtoul(data+1, &data, 10); if (data >= data_limit || *data != ')') return 0; to = (p1<<24) | (p2<<16) | (p3<<8) | p4; port = (p5<<8) | p6; /* * Now update or create an masquerade entry for it */ #if DEBUG_CONFIG_IP_MASQ_FTP printk("PASV response %lX:%X %X:%X detected\n", ntohl(ms->saddr), 0, to, port); #endif n_ms = ip_masq_out_get_2(iph->protocol, ms->saddr, 0, htonl(to), htons(port)); if (n_ms) { /* existing masquerade, clear timer */ ip_masq_set_expire(n_ms,0); } else { n_ms = ip_masq_new(dev, IPPROTO_TCP, ms->saddr, 0, htonl(to), htons(port), IP_MASQ_F_NO_SPORT); if (n_ms==NULL) return 0; n_ms->control = ms; /* keepalive from data to the control channel */ ms->flags |= IP_MASQ_F_CONTROL; /* this is a control channel */ } /* * keep for a bit longer than tcp_fin, client may not issue open * to server port before tcp_fin_timeout. */ ip_masq_set_expire(n_ms, ip_masq_expire->tcp_fin_timeout*3); ms->flags &= ~IP_MASQ_F_FTP_PASV; return 0; /* no diff required for incoming packets, thank goodness */ }
int masq_irc_out (struct ip_masq_app *mapp, struct ip_masq *ms, struct sk_buff **skb_p, __u32 maddr) { struct sk_buff *skb; struct iphdr *iph; struct tcphdr *th; char *data, *data_limit; __u32 s_addr; __u16 s_port; struct ip_masq *n_ms; char buf[20]; /* "m_addr m_port" (dec base)*/ unsigned buf_len; int diff; char *dcc_p, *addr_beg_p, *addr_end_p; skb = *skb_p; iph = skb->nh.iph; th = (struct tcphdr *)&(((char *)iph)[iph->ihl*4]); data = (char *)&th[1]; /* * Hunt irc DCC string, the _shortest_: * * strlen("\1DCC CHAT chat AAAAAAAA P\1\n")=27 * strlen("\1DCC SCHAT chat AAAAAAAA P\1\n")=28 * strlen("\1DCC SEND F AAAAAAAA P S\1\n")=26 * strlen("\1DCC MOVE F AAAAAAAA P S\1\n")=26 * strlen("\1DCC TSEND F AAAAAAAA P S\1\n")=27 * AAAAAAAAA: bound addr (1.0.0.0==16777216, min 8 digits) * P: bound port (min 1 d ) * F: filename (min 1 d ) * S: size (min 1 d ) * 0x01, \n: terminators */ data_limit = skb->h.raw + skb->len; while (data < (data_limit - ( 22 + MAXMATCHLEN ) ) ) { int i; if (memcmp(data,"\1DCC ",5)) { data ++; continue; } dcc_p = data; data += 5; /* point to DCC cmd */ for(i=0; i<NUM_DCCPROTO; i++) { /* * go through the table and hunt a match string */ if( memcmp(data, dccprotos[i].match, dccprotos[i].matchlen ) == 0 ) { data += dccprotos[i].matchlen; /* * skip next string. */ while( *data++ != ' ') /* * must still parse, at least, "AAAAAAAA P\1\n", * 12 bytes left. */ if (data > (data_limit-12)) return 0; addr_beg_p = data; /* * client bound address in dec base */ s_addr = simple_strtoul(data,&data,10); if (*data++ !=' ') continue; /* * client bound port in dec base */ s_port = simple_strtoul(data,&data,10); addr_end_p = data; /* * Now create an masquerade entry for it * must set NO_DPORT and NO_DADDR because * connection is requested by another client. */ n_ms = ip_masq_new(IPPROTO_TCP, maddr, 0, htonl(s_addr),htons(s_port), 0, 0, IP_MASQ_F_NO_DPORT|IP_MASQ_F_NO_DADDR); if (n_ms==NULL) return 0; /* * Replace the old "address port" with the new one */ buf_len = sprintf(buf,"%lu %u", ntohl(n_ms->maddr),ntohs(n_ms->mport)); /* * Calculate required delta-offset to keep TCP happy */ diff = buf_len - (addr_end_p-addr_beg_p); *addr_beg_p = '\0'; IP_MASQ_DEBUG(1-debug, "masq_irc_out(): '%s' %X:%X detected (diff=%d)\n", dcc_p, s_addr,s_port, diff); /* * No shift. */ if (diff==0) { /* * simple case, just copy. */ memcpy(addr_beg_p,buf,buf_len); } else { *skb_p = ip_masq_skb_replace(skb, GFP_ATOMIC, addr_beg_p, addr_end_p-addr_beg_p, buf, buf_len); } ip_masq_listen(n_ms); ip_masq_put(n_ms); return diff; } } } return 0; }