Lines Matching defs:dptr
56 const char **dptr,
65 const char **dptr,
73 const char **dptr,
83 const char **dptr,
92 const char **dptr,
100 const char **dptr,
110 static int string_len(const struct nf_conn *ct, const char *dptr,
115 while (dptr < limit && isalpha(*dptr)) {
116 dptr++;
122 static int digits_len(const struct nf_conn *ct, const char *dptr,
126 while (dptr < limit && isdigit(*dptr)) {
127 dptr++;
134 static int media_len(const struct nf_conn *ct, const char *dptr,
137 int len = string_len(ct, dptr, limit, shift);
139 dptr += len;
140 if (dptr >= limit || *dptr != ' ')
143 dptr++;
145 return len + digits_len(ct, dptr, limit, shift);
175 static int epaddr_len(const struct nf_conn *ct, const char *dptr,
179 const char *aux = dptr;
181 if (!parse_addr(ct, dptr, &dptr, &addr, limit)) {
182 pr_debug("ip: %s parse failed.!\n", dptr);
187 if (*dptr == ':') {
188 dptr++;
189 dptr += digits_len(ct, dptr, limit, shift);
191 return dptr - aux;
195 static int skp_epaddr_len(const struct nf_conn *ct, const char *dptr,
198 const char *start = dptr;
204 while (dptr < limit &&
205 *dptr != '@' && *dptr != '\r' && *dptr != '\n') {
207 dptr++;
210 if (dptr < limit && *dptr == '@') {
211 dptr++;
214 dptr = start;
218 return epaddr_len(ct, dptr, limit, shift);
228 const char *dptr, unsigned int datalen,
232 const char *start = dptr, *limit = dptr + datalen, *end;
238 mlen = string_len(ct, dptr, limit, NULL);
241 dptr += mlen;
242 if (++dptr >= limit)
246 for (; dptr < limit - strlen("sip:"); dptr++) {
247 if (*dptr == '\r' || *dptr == '\n')
249 if (strnicmp(dptr, "sip:", strlen("sip:")) == 0) {
250 dptr += strlen("sip:");
254 if (!skp_epaddr_len(ct, dptr, limit, &shift))
256 dptr += shift;
258 if (!parse_addr(ct, dptr, &end, addr, limit))
269 if (end == dptr)
271 *matchoff = dptr - start;
272 *matchlen = end - dptr;
301 static const char *sip_follow_continuation(const char *dptr, const char *limit)
304 if (++dptr >= limit)
308 if (*(dptr - 1) == '\r' && *dptr == '\n') {
309 if (++dptr >= limit)
314 if (*dptr != ' ' && *dptr != '\t')
318 for (; dptr < limit; dptr++) {
319 if (*dptr != ' ' && *dptr != '\t')
322 return dptr;
325 static const char *sip_skip_whitespace(const char *dptr, const char *limit)
327 for (; dptr < limit; dptr++) {
328 if (*dptr == ' ')
330 if (*dptr != '\r' && *dptr != '\n')
332 dptr = sip_follow_continuation(dptr, limit);
333 if (dptr == NULL)
336 return dptr;
340 static const char *ct_sip_header_search(const char *dptr, const char *limit,
343 for (limit -= len; dptr < limit; dptr++) {
344 if (*dptr == '\r' || *dptr == '\n') {
345 dptr = sip_follow_continuation(dptr, limit);
346 if (dptr == NULL)
351 if (strnicmp(dptr, needle, len) == 0)
352 return dptr;
357 int ct_sip_get_header(const struct nf_conn *ct, const char *dptr,
363 const char *start = dptr, *limit = dptr + datalen;
366 for (dptr += dataoff; dptr < limit; dptr++) {
368 if (*dptr != '\r' && *dptr != '\n')
370 if (++dptr >= limit)
372 if (*(dptr - 1) == '\r' && *dptr == '\n') {
373 if (++dptr >= limit)
378 if (*dptr == ' ' || *dptr == '\t')
383 if (limit - dptr >= hdr->len &&
384 strnicmp(dptr, hdr->name, hdr->len) == 0)
385 dptr += hdr->len;
386 else if (hdr->cname && limit - dptr >= hdr->clen + 1 &&
387 strnicmp(dptr, hdr->cname, hdr->clen) == 0 &&
388 !isalpha(*(dptr + hdr->clen)))
389 dptr += hdr->clen;
394 dptr = sip_skip_whitespace(dptr, limit);
395 if (dptr == NULL)
397 if (*dptr != ':' || ++dptr >= limit)
401 dptr = sip_skip_whitespace(dptr, limit);
402 if (dptr == NULL)
405 *matchoff = dptr - start;
407 dptr = ct_sip_header_search(dptr, limit, hdr->search,
409 if (!dptr)
411 dptr += hdr->slen;
414 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
417 *matchoff = dptr - start + shift;
425 static int ct_sip_next_header(const struct nf_conn *ct, const char *dptr,
431 const char *start = dptr, *limit = dptr + datalen;
434 dptr += dataoff;
436 dptr = ct_sip_header_search(dptr, limit, ",", strlen(","));
437 if (!dptr)
440 dptr = ct_sip_header_search(dptr, limit, hdr->search, hdr->slen);
441 if (!dptr)
443 dptr += hdr->slen;
445 *matchoff = dptr - start;
446 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
455 static int ct_sip_walk_headers(const struct nf_conn *ct, const char *dptr,
464 ret = ct_sip_next_header(ct, dptr, dataoff, datalen,
476 ret = ct_sip_get_header(ct, dptr, dataoff, datalen,
495 int ct_sip_parse_header_uri(const struct nf_conn *ct, const char *dptr,
501 const char *c, *limit = dptr + datalen;
505 ret = ct_sip_walk_headers(ct, dptr, dataoff ? *dataoff : 0, datalen,
511 if (!parse_addr(ct, dptr + *matchoff, &c, addr, limit))
523 *dataoff = c - dptr;
528 static int ct_sip_parse_param(const struct nf_conn *ct, const char *dptr,
533 const char *limit = dptr + datalen;
537 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
539 limit = dptr + datalen;
541 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
550 *matchoff = start - dptr;
556 int ct_sip_parse_address_param(const struct nf_conn *ct, const char *dptr,
562 const char *limit = dptr + datalen;
565 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
567 limit = dptr + datalen;
569 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
576 *matchoff = start - dptr;
583 int ct_sip_parse_numerical_param(const struct nf_conn *ct, const char *dptr,
589 const char *limit = dptr + datalen;
593 limit = ct_sip_header_search(dptr + dataoff, limit, ",", strlen(","));
595 limit = dptr + datalen;
597 start = ct_sip_header_search(dptr + dataoff, limit, name, strlen(name));
606 *matchoff = start - dptr;
613 static int ct_sip_parse_transport(struct nf_conn *ct, const char *dptr,
619 if (ct_sip_parse_param(ct, dptr, dataoff, datalen, "transport=",
621 if (!strnicmp(dptr + matchoff, "TCP", strlen("TCP")))
623 else if (!strnicmp(dptr + matchoff, "UDP", strlen("UDP")))
655 static const char *ct_sdp_header_search(const char *dptr, const char *limit,
658 for (limit -= len; dptr < limit; dptr++) {
659 if (*dptr == '\r' || *dptr == '\n')
661 if (strncmp(dptr, needle, len) == 0)
662 return dptr;
671 int ct_sip_get_sdp_header(const struct nf_conn *ct, const char *dptr,
679 const char *start = dptr, *limit = dptr + datalen;
682 for (dptr += dataoff; dptr < limit; dptr++) {
684 if (*dptr != '\r' && *dptr != '\n')
686 if (++dptr >= limit)
688 if (*(dptr - 1) == '\r' && *dptr == '\n') {
689 if (++dptr >= limit)
694 limit - dptr >= thdr->len &&
695 strnicmp(dptr, thdr->name, thdr->len) == 0)
697 else if (limit - dptr >= hdr->len &&
698 strnicmp(dptr, hdr->name, hdr->len) == 0)
699 dptr += hdr->len;
703 *matchoff = dptr - start;
705 dptr = ct_sdp_header_search(dptr, limit, hdr->search,
707 if (!dptr)
709 dptr += hdr->slen;
712 *matchlen = hdr->match_len(ct, dptr, limit, &shift);
715 *matchoff = dptr - start + shift;
722 static int ct_sip_parse_sdp_addr(const struct nf_conn *ct, const char *dptr,
731 ret = ct_sip_get_sdp_header(ct, dptr, dataoff, datalen, type, term,
736 if (!parse_addr(ct, dptr + *matchoff, NULL, addr,
737 dptr + *matchoff + *matchlen))
792 const char **dptr, unsigned int *datalen,
868 !nf_nat_sdp_port(skb, dataoff, dptr, datalen,
890 ret = nf_nat_sdp_media(skb, dataoff, dptr, datalen,
914 static const struct sdp_media_type *sdp_media_type(const char *dptr,
924 strncmp(dptr + matchoff, t->name, t->len))
932 const char **dptr, unsigned int *datalen,
955 if (ct_sip_get_sdp_header(ct, *dptr, 0, *datalen,
965 if (ct_sip_parse_sdp_addr(ct, *dptr, sdpoff, *datalen,
972 if (ct_sip_get_sdp_header(ct, *dptr, mediaoff, *datalen,
979 t = sdp_media_type(*dptr, mediaoff, medialen);
987 port = simple_strtoul(*dptr + mediaoff, NULL, 10);
995 if (ct_sip_parse_sdp_addr(ct, *dptr, mediaoff, *datalen,
1005 ret = set_expected_rtp_rtcp(skb, dataoff, dptr, datalen,
1013 ret = nf_nat_sdp_addr(skb, dataoff, dptr, datalen,
1025 ret = nf_nat_sdp_session(skb, dataoff, dptr, datalen, sdpoff,
1031 const char **dptr, unsigned int *datalen,
1040 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1047 const char **dptr, unsigned int *datalen,
1056 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1063 const char **dptr, unsigned int *datalen,
1072 return process_sdp(skb, dataoff, dptr, datalen, cseq);
1079 const char **dptr, unsigned int *datalen,
1088 ret = process_sdp(skb, dataoff, dptr, datalen, cseq);
1095 const char **dptr, unsigned int *datalen,
1110 const char **dptr, unsigned int *datalen,
1138 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1140 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1142 ret = ct_sip_parse_header_uri(ct, *dptr, NULL, *datalen,
1154 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen, *datalen,
1158 if (ct_sip_parse_numerical_param(ct, *dptr,
1184 ret = nf_nat_sip_expect(skb, dataoff, dptr, datalen, exp,
1201 const char **dptr, unsigned int *datalen,
1231 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_EXPIRES,
1233 expires = simple_strtoul(*dptr + matchoff, NULL, 10);
1238 ret = ct_sip_parse_header_uri(ct, *dptr, &coff, *datalen,
1251 if (ct_sip_parse_transport(ct, *dptr, matchoff + matchlen,
1255 ret = ct_sip_parse_numerical_param(ct, *dptr,
1283 const char **dptr, unsigned int *datalen)
1292 code = simple_strtoul(*dptr + strlen("SIP/2.0 "), NULL, 10);
1296 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1299 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1311 strnicmp(*dptr + matchend, handler->method, handler->len))
1313 return handler->response(skb, dataoff, dptr, datalen,
1320 const char **dptr, unsigned int *datalen)
1334 strnicmp(*dptr, handler->method, handler->len))
1337 if (ct_sip_get_header(ct, *dptr, 0, *datalen, SIP_HDR_CSEQ,
1340 cseq = simple_strtoul(*dptr + matchoff, NULL, 10);
1344 return handler->request(skb, dataoff, dptr, datalen, cseq);
1350 unsigned int dataoff, const char **dptr,
1356 if (strnicmp(*dptr, "SIP/2.0 ", strlen("SIP/2.0 ")) != 0)
1357 ret = process_sip_request(skb, dataoff, dptr, datalen);
1359 ret = process_sip_response(skb, dataoff, dptr, datalen);
1363 if (nf_nat_sip && !nf_nat_sip(skb, dataoff, dptr, datalen))
1377 const char *dptr, *end;
1399 dptr = skb->data + dataoff;
1405 if (ct_sip_get_header(ct, dptr, 0, datalen,
1410 clen = simple_strtoul(dptr + matchoff, (char **)&end, 10);
1411 if (dptr + matchoff == end)
1414 if (end + strlen("\r\n\r\n") > dptr + datalen)
1421 msglen = origlen = end - dptr;
1423 ret = process_sip_msg(skb, ct, dataoff, &dptr, &msglen);
1430 dptr += msglen;
1447 const char *dptr;
1459 dptr = skb->data + dataoff;
1464 return process_sip_msg(skb, ct, dataoff, &dptr, &datalen);