sys/contrib/ipfilter/netinet/ip_irc_pxy.c

   1 /*
   2  * Copyright (C) 2012 by Darren Reed.
   3  *
   4  * See the IPFILTER.LICENCE file for details on licencing.
   5  *
   6  * $Id$
   7  */
   8
   9 #define IPF_IRC_PROXY
  10
  11 #define IPF_IRCBUFSZ    96      /* This *MUST* be >= 64! */
  12
  13
  14 void ipf_p_irc_main_load(void);
  15 void ipf_p_irc_main_unload(void);
  16 int ipf_p_irc_new(void *, fr_info_t *, ap_session_t *, nat_t *);
  17 int ipf_p_irc_out(void *, fr_info_t *, ap_session_t *, nat_t *);
  18 int ipf_p_irc_send(fr_info_t *, nat_t *);
  19 int ipf_p_irc_complete(ircinfo_t *, char *, size_t);
  20 u_short ipf_irc_atoi(char **);
  21
  22 static  frentry_t       ircnatfr;
  23
  24 int     irc_proxy_init = 0;
  25
  26
  27 /*
  28  * Initialize local structures.
  29  */
  30 void
  31 ipf_p_irc_main_load()
  32 {
  33         bzero((char *)&ircnatfr, sizeof(ircnatfr));
  34         ircnatfr.fr_ref = 1;
  35         ircnatfr.fr_flags = FR_INQUE|FR_PASS|FR_QUICK|FR_KEEPSTATE;
  36         MUTEX_INIT(&ircnatfr.fr_lock, "IRC proxy rule lock");
  37         irc_proxy_init = 1;
  38 }
  39
  40
  41 void
  42 ipf_p_irc_main_unload()
  43 {
  44         if (irc_proxy_init == 1) {
  45                 MUTEX_DESTROY(&ircnatfr.fr_lock);
  46                 irc_proxy_init = 0;
  47         }
  48 }
  49
  50
  51 const char *ipf_p_irc_dcctypes[] = {
  52         "CHAT ",        /* CHAT chat ipnumber portnumber */
  53         "SEND ",        /* SEND filename ipnumber portnumber */
  54         "MOVE ",
  55         "TSEND ",
  56         "SCHAT ",
  57         NULL,
  58 };
  59
  60
  61 /*
  62  * :A PRIVMSG B :^ADCC CHAT chat 0 0^A\r\n
  63  * PRIVMSG B ^ADCC CHAT chat 0 0^A\r\n
  64  */
  65
  66
  67 int
  68 ipf_p_irc_complete(ircp, buf, len)
  69         ircinfo_t *ircp;
  70         char *buf;
  71         size_t len;
  72 {
  73         register char *s, c;
  74         register size_t i;
  75         u_32_t l;
  76         int j, k;
  77
  78         ircp->irc_ipnum = 0;
  79         ircp->irc_port = 0;
  80
  81         if (len < 31)
  82                 return 0;
  83         s = buf;
  84         c = *s++;
  85         i = len - 1;
  86
  87         if ((c != ':') && (c != 'P'))
  88                 return 0;
  89
  90         if (c == ':') {
  91                 /*
  92                  * Loosely check that the source is a nickname of some sort
  93                  */
  94                 s++;
  95                 c = *s;
  96                 ircp->irc_snick = s;
  97                 if (!ISALPHA(c))
  98                         return 0;
  99                 i--;
 100                 for (c = *s; !ISSPACE(c) && (i > 0); i--)
 101                         c = *s++;
 102                 if (i < 31)
 103                         return 0;
 104                 if (c != 'P')
 105                         return 0;
 106         } else
 107                 ircp->irc_snick = NULL;
 108
 109         /*
 110          * Check command string
 111          */
 112         if (strncmp(s, "PRIVMSG ", 8))
 113                 return 0;
 114         i -= 8;
 115         s += 8;
 116         c = *s;
 117         ircp->irc_dnick = s;
 118
 119         /*
 120          * Loosely check that the destination is a nickname of some sort
 121          */
 122         if (!ISALPHA(c))
 123                 return 0;
 124         for (; !ISSPACE(c) && (i > 0); i--)
 125                 c = *s++;
 126         if (i < 20)
 127                 return 0;
 128         s++,
 129         i--;
 130
 131         /*
 132          * Look for a ^A to start the DCC
 133          */
 134         c = *s;
 135         if (c == ':') {
 136                 s++;
 137                 c = *s;
 138         }
 139
 140         if (strncmp(s, "\001DCC ", 4))
 141                 return 0;
 142
 143         i -= 4;
 144         s += 4;
 145
 146         /*
 147          * Check for a recognised DCC command
 148          */
 149         for (j = 0, k = 0; ipf_p_irc_dcctypes[j]; j++) {
 150                 k = MIN(strlen(ipf_p_irc_dcctypes[j]), i);
 151                 if (!strncmp(ipf_p_irc_dcctypes[j], s, k))
 152                         break;
 153         }
 154         if (!ipf_p_irc_dcctypes[j])
 155                 return 0;
 156
 157         ircp->irc_type = s;
 158         i -= k;
 159         s += k;
 160
 161         if (i < 11)
 162                 return 0;
 163
 164         /*
 165          * Check for the arg
 166          */
 167         c = *s;
 168         if (ISSPACE(c))
 169                 return 0;
 170         ircp->irc_arg = s;
 171         for (; (c != ' ') && (c != '\001') && (i > 0); i--)
 172                 c = *s++;
 173
 174         if (c == '\001')        /* In reality a ^A can quote another ^A...*/
 175                 return 0;
 176
 177         if (i < 5)
 178                 return 0;
 179
 180         s++;
 181         i--;
 182         c = *s;
 183         if (!ISDIGIT(c))
 184                 return 0;
 185         ircp->irc_addr = s;
 186         /*
 187          * Get the IP#
 188          */
 189         for (l = 0; ISDIGIT(c) && (i > 0); i--) {
 190                 l *= 10;
 191                 l += c - '0';
 192                 c = *s++;
 193         }
 194
 195         if (i < 4)
 196                 return 0;
 197
 198         if (c != ' ')
 199                 return 0;
 200
 201         ircp->irc_ipnum = l;
 202         s++;
 203         i--;
 204         c = *s;
 205         if (!ISDIGIT(c))
 206                 return 0;
 207         /*
 208          * Get the port#
 209          */
 210         for (l = 0; ISDIGIT(c) && (i > 0); i--) {
 211                 l *= 10;
 212                 l += c - '0';
 213                 c = *s++;
 214         }
 215         if (i < 3)
 216                 return 0;
 217         if (strncmp(s, "\001\r\n", 3))
 218                 return 0;
 219         s += 3;
 220         ircp->irc_len = s - buf;
 221         ircp->irc_port = l;
 222         return 1;
 223 }
 224
 225
 226 int
 227 ipf_p_irc_new(arg, fin, aps, nat)
 228         void *arg;
 229         fr_info_t *fin;
 230         ap_session_t *aps;
 231         nat_t *nat;
 232 {
 233         ircinfo_t *irc;
 234
 235         if (fin->fin_v != 4)
 236                 return -1;
 237
 238         KMALLOC(irc, ircinfo_t *);
 239         if (irc == NULL)
 240                 return -1;
 241
 242         nat = nat;      /* LINT */
 243
 244         aps->aps_data = irc;
 245         aps->aps_psiz = sizeof(ircinfo_t);
 246
 247         bzero((char *)irc, sizeof(*irc));
 248         return 0;
 249 }
 250
 251
 252 int
 253 ipf_p_irc_send(fin, nat)
 254         fr_info_t *fin;
 255         nat_t *nat;
 256 {
 257         char ctcpbuf[IPF_IRCBUFSZ], newbuf[IPF_IRCBUFSZ];
 258         tcphdr_t *tcp, tcph, *tcp2 = &tcph;
 259         int off, inc = 0, i, dlen;
 260         ipf_main_softc_t *softc;
 261         size_t nlen = 0, olen;
 262         struct in_addr swip;
 263         u_short a5, sp;
 264         ircinfo_t *irc;
 265         fr_info_t fi;
 266         nat_t *nat2;
 267         u_int a1;
 268         ip_t *ip;
 269         mb_t *m;
 270 #if SOLARIS
 271         mb_t *m1;
 272 #endif
 273         softc = fin->fin_main_soft;
 274
 275         m = fin->fin_m;
 276         ip = fin->fin_ip;
 277         tcp = (tcphdr_t *)fin->fin_dp;
 278         bzero(ctcpbuf, sizeof(ctcpbuf));
 279         off = (char *)tcp - (char *)ip + (TCP_OFF(tcp) << 2) + fin->fin_ipoff;
 280
 281         dlen = MSGDSIZE(m) - off;
 282         if (dlen <= 0)
 283                 return 0;
 284         COPYDATA(m, off, MIN(sizeof(ctcpbuf), dlen), ctcpbuf);
 285
 286         if (dlen <= 0)
 287                 return 0;
 288         ctcpbuf[sizeof(ctcpbuf) - 1] = '\0';
 289         *newbuf = '\0';
 290
 291         irc = nat->nat_aps->aps_data;
 292         if (ipf_p_irc_complete(irc, ctcpbuf, dlen) == 0)
 293                 return 0;
 294
 295         /*
 296          * check that IP address in the DCC reply is the same as the
 297          * sender of the command - prevents use for port scanning.
 298          */
 299         if (irc->irc_ipnum != ntohl(nat->nat_osrcaddr))
 300                 return 0;
 301
 302         a5 = irc->irc_port;
 303
 304         /*
 305          * Calculate new address parts for the DCC command
 306          */
 307         a1 = ntohl(ip->ip_src.s_addr);
 308         olen = irc->irc_len;
 309         i = irc->irc_addr - ctcpbuf;
 310         i++;
 311         (void) strncpy(newbuf, ctcpbuf, i);
 312         /* DO NOT change these! */
 313         (void) snprintf(newbuf, sizeof(newbuf), "%u %u\001\r\n", a1, a5);
 314
 315         nlen = strlen(newbuf);
 316         inc = nlen - olen;
 317
 318         if ((inc + fin->fin_plen) > 65535)
 319                 return 0;
 320
 321 #if SOLARIS
 322         for (m1 = m; m1->b_cont; m1 = m1->b_cont)
 323                 ;
 324         if ((inc > 0) && (m1->b_datap->db_lim - m1->b_wptr < inc)) {
 325                 mblk_t *nm;
 326
 327                 /* alloc enough to keep same trailer space for lower driver */
 328                 nm = allocb(nlen, BPRI_MED);
 329                 PANIC((!nm),("ipf_p_irc_out: allocb failed"));
 330
 331                 nm->b_band = m1->b_band;
 332                 nm->b_wptr += nlen;
 333
 334                 m1->b_wptr -= olen;
 335                 PANIC((m1->b_wptr < m1->b_rptr),
 336                       ("ipf_p_irc_out: cannot handle fragmented data block"));
 337
 338                 linkb(m1, nm);
 339         } else {
 340 # if SOLARIS && defined(ICK_VALID)
 341                 if (m1->b_datap->db_struiolim == m1->b_wptr)
 342                         m1->b_datap->db_struiolim += inc;
 343                 m1->b_datap->db_struioflag &= ~STRUIO_IP;
 344 # endif
 345                 m1->b_wptr += inc;
 346         }
 347 #else
 348         if (inc < 0)
 349                 m_adj(m, inc);
 350         /* the mbuf chain will be extended if necessary by m_copyback() */
 351 #endif
 352         COPYBACK(m, off, nlen, newbuf);
 353         fin->fin_flx |= FI_DOCKSUM;
 354
 355         if (inc != 0) {
 356 #if SOLARIS
 357                 register u_32_t sum1, sum2;
 358
 359                 sum1 = fin->fin_plen;
 360                 sum2 = fin->fin_plen + inc;
 361
 362                 /* Because ~1 == -2, We really need ~1 == -1 */
 363                 if (sum1 > sum2)
 364                         sum2--;
 365                 sum2 -= sum1;
 366                 sum2 = (sum2 & 0xffff) + (sum2 >> 16);
 367
 368                 ipf_fix_outcksum(0, &ip->ip_sum, sum2, 0);
 369 #endif
 370                 fin->fin_plen += inc;
 371                 ip->ip_len = htons(fin->fin_plen);
 372                 fin->fin_dlen += inc;
 373         }
 374
 375         /*
 376          * Add skeleton NAT entry for connection which will come back the
 377          * other way.
 378          */
 379         sp = htons(a5);
 380         /*
 381          * Don't allow the PORT command to specify a port < 1024 due to
 382          * security crap.
 383          */
 384         if (ntohs(sp) < 1024)
 385                 return 0;
 386
 387         /*
 388          * The server may not make the connection back from port 20, but
 389          * it is the most likely so use it here to check for a conflicting
 390          * mapping.
 391          */
 392         bcopy((caddr_t)fin, (caddr_t)&fi, sizeof(fi));
 393         fi.fin_data[0] = sp;
 394         fi.fin_data[1] = fin->fin_data[1];
 395         nat2 = ipf_nat_outlookup(fin, IPN_TCP, nat->nat_pr[1], nat->nat_nsrcip,
 396                              ip->ip_dst);
 397         if (nat2 == NULL) {
 398 #ifdef USE_MUTEXES
 399                 ipf_nat_softc_t *softn = softc->ipf_nat_soft;
 400 #endif
 401
 402                 bcopy((caddr_t)fin, (caddr_t)&fi, sizeof(fi));
 403                 bzero((char *)tcp2, sizeof(*tcp2));
 404                 tcp2->th_win = htons(8192);
 405                 tcp2->th_sport = sp;
 406                 tcp2->th_dport = 0; /* XXX - don't specify remote port */
 407                 fi.fin_data[0] = ntohs(sp);
 408                 fi.fin_data[1] = 0;
 409                 fi.fin_dp = (char *)tcp2;
 410                 fi.fin_fr = &ircnatfr;
 411                 fi.fin_dlen = sizeof(*tcp2);
 412                 fi.fin_plen = fi.fin_hlen + sizeof(*tcp2);
 413                 swip = ip->ip_src;
 414                 ip->ip_src = nat->nat_nsrcip;
 415                 MUTEX_ENTER(&softn->ipf_nat_new);
 416                 nat2 = ipf_nat_add(&fi, nat->nat_ptr, NULL,
 417                                NAT_SLAVE|IPN_TCP|SI_W_DPORT, NAT_OUTBOUND);
 418                 MUTEX_EXIT(&softn->ipf_nat_new);
 419                 if (nat2 != NULL) {
 420                         (void) ipf_nat_proto(&fi, nat2, 0);
 421                         MUTEX_ENTER(&nat2->nat_lock);
 422                         ipf_nat_update(&fi, nat2);
 423                         MUTEX_EXIT(&nat2->nat_lock);
 424
 425                         (void) ipf_state_add(softc, &fi, NULL, SI_W_DPORT);
 426                 }
 427                 ip->ip_src = swip;
 428         }
 429         return inc;
 430 }
 431
 432
 433 int
 434 ipf_p_irc_out(arg, fin, aps, nat)
 435         void *arg;
 436         fr_info_t *fin;
 437         ap_session_t *aps;
 438         nat_t *nat;
 439 {
 440         aps = aps;      /* LINT */
 441         return ipf_p_irc_send(fin, nat);
 442 }