-/* ------------------------------------------------\r
-Copyright 2014 AT&T Intellectual Property\r
- Licensed under the Apache License, Version 2.0 (the "License");\r
- you may not use this file except in compliance with the License.\r
- You may obtain a copy of the License at\r
-\r
- http://www.apache.org/licenses/LICENSE-2.0\r
-\r
- Unless required by applicable law or agreed to in writing, software\r
- distributed under the License is distributed on an "AS IS" BASIS,\r
- WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
- See the License for the specific language governing permissions and\r
- limitations under the License.\r
- ------------------------------------------- */\r
-\r
-#include "rts_external.h"\r
-#include <stdio.h>\r
-#include <regex.h>\r
-#include "gsconfig.h"\r
-#include "gstypes.h"\r
-\r
-\r
-#include "stdlib.h"\r
-\r
-\r
-gs_retval_t str_assign_with_copy(struct FTA * f, struct gs_string * dest, struct gs_string * src)\r
-{\r
- if ((dest->data = fta_alloc(f,src->length))==0) {\r
- return -1;\r
- }\r
- dest->length=src->length;\r
- dest->owner=f; \r
- memcpy(dest->data,src->data,src->length);\r
- return 0;\r
-}\r
-\r
-gs_retval_t str_assign_with_copy_in_tuple(struct string32 * dest, struct gs_string * src,\r
- gs_sp_t start, gs_sp_t buf)\r
-{\r
- gs_uint32_t st;\r
- st=(unsigned int)(buf-start);\r
-// dest->length=htonl(src->length);\r
-// dest->reserved=htonl(0);\r
-// dest->offset=htonl(st);\r
- dest->length=src->length;\r
- dest->reserved=0;\r
- dest->offset=st;\r
- memcpy(buf,src->data,src->length);\r
- return 0;\r
-}\r
-\r
-\r
-\r
-gs_retval_t str_replace( struct FTA * f, struct gs_string * dest, struct gs_string * src )\r
-{\r
- str_destroy(dest);\r
- return str_assign_with_copy(f, dest, src);\r
-}\r
-\r
-/* Searching within a string */\r
-\r
-\r
-gs_retval_t str_exists_substr( struct gs_string * s1, struct gs_string * s2)\r
-{\r
- register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data);\r
- register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data);\r
- register gs_uint8_t s2f=st2[0];\r
- register gs_int32_t len1 = s1->length-s2->length; /* the lates point I have to find\r
- a match of the first char */\r
- register gs_int32_t len2 = s2->length;\r
- register gs_int32_t x,y;\r
-\r
-\r
- for (x=0; x<len1 ; x++)\r
- {\r
- if (st1[x]==s2f) {\r
- for (y=0; y<len2 && st1[x+y]==st2[y];y++);\r
- if (y==len2) {\r
- return 1;\r
- }\r
- }\r
- }\r
- return 0;\r
-}\r
-\r
-\r
-gs_uint32_t str_match_offset( gs_uint32_t offset, struct gs_string * s1, struct gs_string * s2) {\r
- register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data);\r
- register gs_uint8_t * st2 = (gs_uint8_t *)(&s2->data[offset]);\r
- register gs_int32_t x;\r
- register gs_int32_t len2 = s2->length-offset;\r
- register gs_int32_t len1 = s1->length;\r
- if (len2<len1) return 0;\r
- for(x=0; x<len1; x++) {\r
- if (st1[x]!=st2[x]) return 0;\r
- }\r
- return 1;\r
-}\r
-\r
-\r
-gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val, struct gs_string * s2) {\r
- register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data);\r
- register gs_uint8_t v = (unsigned char) val;\r
-// if ((s2->length <= offset)||(offset<0)) return 0;\r
- if (s2->length <= offset) return 0;\r
- return (st2[offset]==v)?1:0;\r
-}\r
-\r
-\r
-gs_retval_t str_compare( struct gs_string * str1, struct gs_string * str2)\r
-{\r
- gs_int32_t len;\r
- gs_int32_t x;\r
- len = (str1->length>str2->length)?str2->length:str1->length;\r
- for(x=0;x<len;x++) {\r
- if (str1->data[x]>str2->data[x]) {\r
- return 1;\r
- }\r
- if (str1->data[x]<str2->data[x]) {\r
- return -1;\r
- }\r
- }\r
-\r
- if (str1->length>str2->length) {\r
- return 1;\r
- }\r
- if (str2->length>str1->length) {\r
- return -1;\r
- }\r
- return 0;\r
-}\r
-\r
-gs_retval_t str_constructor(struct gs_string *s, gs_sp_t l){\r
- s->data = l;\r
- s->length = 0;\r
- while(l[s->length] != '\0') s->length++;\r
- s->owner = NULL; \r
- return(0);\r
-}\r
-\r
-\r
-gs_param_handle_t register_handle_for_str_regex_match_slot_1(struct FTA * f,\r
- struct gs_string* pattern) {\r
- regex_t * reg;\r
- if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) {\r
- return 0;\r
- }\r
- if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) {\r
- return 0;\r
- }\r
- return (gs_param_handle_t) reg;\r
-}\r
-\r
-gs_uint32_t str_regex_match(struct gs_string* str, gs_param_handle_t pattern_handle) {\r
- regex_t * reg = (regex_t *) pattern_handle ;\r
- gs_sp_t source = (gs_sp_t)(str->data);\r
- int res;\r
- static gs_sp_t d=0;\r
- static gs_uint32_t dlen=0;\r
- // grow our static buffer to the longest string we ever see\r
- if ((str->length+1) >= dlen) {\r
- if (d!=0) fta_free(0,(void*)d);\r
- dlen=0;\r
- d=0;\r
- if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0;\r
- dlen=str->length+1;\r
- }\r
- \r
- if (str->length==0) return 0;\r
-\r
- // copy the string and 0 terminate it\r
- memcpy((void *)d,(void *) str->data, str->length);\r
- d[str->length]=0;\r
- \r
- res = REG_NOMATCH;\r
- res = regexec(reg, d, 0, NULL, 0);\r
- return (res==REG_NOMATCH)?0:1;\r
-}\r
-\r
-\r
-gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle) {\r
- regex_t * x = (regex_t *) handle;\r
- regfree(x);\r
- if (x!=0) fta_free(0,(void *)x);\r
- return 0;\r
-}\r
-\r
-gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(struct FTA * f,\r
- struct gs_string* pattern) {\r
- regex_t * reg;\r
- if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) {\r
- return 0;\r
- }\r
- if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) {\r
- return 0;\r
- }\r
- return (gs_param_handle_t) reg;\r
-}\r
-\r
-gs_uint32_t str_partial_regex_match(struct gs_string* str,\r
- gs_param_handle_t pattern_handle,\r
- gs_uint32_t maxlen) {\r
- regex_t * reg = (regex_t *) pattern_handle ;\r
- gs_sp_t source = (gs_sp_t)(str->data);\r
- gs_int32_t res;\r
- gs_int32_t end;\r
- static gs_sp_t d=0;\r
- static gs_uint32_t dlen=0;\r
- // grow our static buffer to the longest string we ever see\r
- if ((str->length+1) >= dlen) {\r
- if (d!=0) fta_free(0,d);\r
- dlen=0;\r
- d=0;\r
- if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0;\r
- dlen=str->length+1;\r
- }\r
- \r
- if (str->length==0) return 0;\r
- \r
- end=(maxlen>(str->length))?(str->length):maxlen;\r
- \r
- // copy the string and 0 terminate it\r
- memcpy((void *)d,(void *) str->data, end);\r
- d[str->length]=0;\r
- \r
- /* HACK ALERT: commented out regnexec invocations to unbreak the build */\r
- res = REG_NOMATCH;\r
- res = regexec(reg,d, 0, NULL, 0);\r
- return (res==REG_NOMATCH)?0:1;\r
-}\r
-\r
-\r
-gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1(\r
- gs_param_handle_t handle) {\r
- regex_t * x = (regex_t *) handle;\r
- regfree(x);\r
- if (x!=0) fta_free(0,(void *)x);\r
- return 0;\r
-}\r
-\r
-\r
-\r
-static gs_uint32_t nextint(struct gs_string *str , gs_uint32_t * offset, gs_uint32_t *res) {\r
- gs_uint8_t * s = (gs_uint8_t *)(str->data);\r
- gs_int32_t v = 0;\r
- *res = 0;\r
- while(*offset<str->length) {\r
- if ((s[*offset]>='0') && (s[*offset]<='9')) {\r
- v=1;\r
- *res= (*res*10) + (gs_uint32_t) (s[*offset]-'0');\r
- } else {\r
- if (v!=0) { // got some valid result\r
- return 1;\r
- } // otherwise skip leading grabage\r
- }\r
- (*offset)++;\r
- }\r
- return v;\r
-}\r
-\r
-\r
-gs_param_handle_t register_handle_for_strtoi_c_slot_0(struct FTA * f, struct gs_string* istr) {\r
- gs_uint32_t offset,r;\r
- offset=0;\r
- if (nextint(istr,&offset,&r)!=0)\r
- return (gs_param_handle_t) r;\r
- return (gs_param_handle_t) 0;\r
-}\r
-gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) {\r
- return 0;\r
-}\r
-\r
-gs_param_handle_t register_handle_for_strtoip_c_slot_0(struct FTA * f, struct gs_string* istr) {\r
- gs_uint32_t ip1,ip2,ip3,ip4,offset,r;\r
- offset=0;\r
- if (nextint(istr,&offset,&ip1)==0) return (gs_param_handle_t)0;\r
- if (nextint(istr,&offset,&ip2)==0) return (gs_param_handle_t)0;\r
- if (nextint(istr,&offset,&ip3)==0) return (gs_param_handle_t)0;\r
- if (nextint(istr,&offset,&ip4)==0) return (gs_param_handle_t)0;\r
- r=ip1<<24|ip2<<16|ip3<<8|ip4;\r
- return (gs_param_handle_t)r;\r
-}\r
-gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) {\r
- return 0;\r
-}\r
-\r
-\r
-///////////////////////////////////////////////////\r
-// ipv6 procedures\r
-\r
-\r
-\r
-gs_retval_t ipv6_compare( struct ipv6_str i1, struct ipv6_str i2){\r
- if(i1.v[0] > i2.v[0])\r
- return 1;\r
- if(i1.v[0] < i2.v[0])\r
- return -1;\r
- if(i1.v[1] > i2.v[1])\r
- return 1;\r
- if(i1.v[1] < i2.v[1])\r
- return -1;\r
- if(i1.v[2] > i2.v[2])\r
- return 1;\r
- if(i1.v[2] < i2.v[2])\r
- return -1;\r
- if(i1.v[3] > i2.v[3])\r
- return 1;\r
- if(i1.v[3] < i2.v[3])\r
- return -1;\r
-\r
- return 0;\r
-}\r
-\r
-gs_retval_t Ipv6_Constructor(struct ipv6_str *s, gs_sp_t l){\r
- gs_uint32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0;\r
- sscanf(l,"%x:%x:%x:%x:%x:%x:%x:%x",&i0,&i1,&i2,&i3,&i4,&i5,&i6,&i7);\r
- s->v[0] = ((i0 & 0xffff) << 16) | (i1 & 0xffff);\r
- s->v[1] = ((i2 & 0xffff) << 16) | (i3 & 0xffff);\r
- s->v[2] = ((i4 & 0xffff) << 16) | (i5 & 0xffff);\r
- s->v[3] = ((i6 & 0xffff) << 16) | (i7 & 0xffff);\r
- return(0);\r
-}\r
-\r
-struct ipv6_str And_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){\r
- struct ipv6_str ret;\r
- ret.v[0] = i1.v[0] & i2.v[0];\r
- ret.v[1] = i1.v[1] & i2.v[1];\r
- ret.v[2] = i1.v[2] & i2.v[2];\r
- ret.v[3] = i1.v[3] & i2.v[3];\r
- return ret;\r
-}\r
-\r
-struct ipv6_str Or_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){\r
- struct ipv6_str ret;\r
- ret.v[0] = i1.v[0] | i2.v[0];\r
- ret.v[1] = i1.v[1] | i2.v[1];\r
- ret.v[2] = i1.v[2] | i2.v[2];\r
- ret.v[3] = i1.v[3] | i2.v[3];\r
- return ret;\r
-}\r
-struct ipv6_str hton_ipv6(struct ipv6_str s){\r
- struct ipv6_str ret;\r
-// ret.v[0] = htonl(s.v[0]);\r
-// ret.v[1] = htonl(s.v[1]);\r
-// ret.v[2] = htonl(s.v[2]);\r
-// ret.v[3] = htonl(s.v[3]);\r
- ret.v[0] = s.v[0];\r
- ret.v[1] = s.v[1];\r
- ret.v[2] = s.v[2];\r
- ret.v[3] = s.v[3];\r
- return ret;\r
-}\r
-\r
-struct ipv6_str ntoh_ipv6(struct ipv6_str s){\r
- struct ipv6_str ret;\r
-// ret.v[0] = ntohl(s.v[0]);\r
-// ret.v[1] = ntohl(s.v[1]);\r
-// ret.v[2] = ntohl(s.v[2]);\r
-// ret.v[3] = ntohl(s.v[3]);\r
- ret.v[0] = s.v[0];\r
- ret.v[1] = s.v[1];\r
- ret.v[2] = s.v[2];\r
- ret.v[3] = s.v[3];\r
- return ret;\r
-}\r
-\r
-\r
+/* ------------------------------------------------
+Copyright 2014 AT&T Intellectual Property
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ ------------------------------------------- */
+
+#include "rts_external.h"
+#include <stdio.h>
+#include <regex.h>
+#include "gsconfig.h"
+#include "gstypes.h"
+
+
+#include "stdlib.h"
+
+
+gs_retval_t str_assign_with_copy(struct FTA * f, struct gs_string * dest, struct gs_string * src)
+{
+ if ((dest->data = fta_alloc(f,src->length))==0) {
+ return -1;
+ }
+ dest->length=src->length;
+ dest->owner=f;
+ memcpy(dest->data,src->data,src->length);
+ return 0;
+}
+
+gs_retval_t str_assign_with_copy_in_tuple(struct string32 * dest, struct gs_string * src,
+ gs_sp_t start, gs_sp_t buf)
+{
+ gs_uint32_t st;
+ st=(unsigned int)(buf-start);
+// dest->length=htonl(src->length);
+// dest->reserved=htonl(0);
+// dest->offset=htonl(st);
+ dest->length=src->length;
+ dest->reserved=0;
+ dest->offset=st;
+ memcpy(buf,src->data,src->length);
+ return 0;
+}
+
+
+
+gs_retval_t str_replace( struct FTA * f, struct gs_string * dest, struct gs_string * src )
+{
+ str_destroy(dest);
+ return str_assign_with_copy(f, dest, src);
+}
+
+/* Searching within a string */
+
+
+gs_retval_t str_exists_substr( struct gs_string * s1, struct gs_string * s2)
+{
+ register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data);
+ register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data);
+ register gs_uint8_t s2f=st2[0];
+ register gs_int32_t len1 = s1->length-s2->length; /* the lates point I have to find
+ a match of the first char */
+ register gs_int32_t len2 = s2->length;
+ register gs_int32_t x,y;
+
+
+ for (x=0; x<len1 ; x++)
+ {
+ if (st1[x]==s2f) {
+ for (y=0; y<len2 && st1[x+y]==st2[y];y++);
+ if (y==len2) {
+ return 1;
+ }
+ }
+ }
+ return 0;
+}
+
+
+gs_uint32_t str_match_offset( gs_uint32_t offset, struct gs_string * s1, struct gs_string * s2) {
+ register gs_uint8_t * st1 = (gs_uint8_t *)(s1->data);
+ register gs_uint8_t * st2 = (gs_uint8_t *)(&s2->data[offset]);
+ register gs_int32_t x;
+ register gs_int32_t len2 = s2->length-offset;
+ register gs_int32_t len1 = s1->length;
+ if (len2<len1) return 0;
+ for(x=0; x<len1; x++) {
+ if (st1[x]!=st2[x]) return 0;
+ }
+ return 1;
+}
+
+
+gs_uint32_t byte_match_offset( gs_uint32_t offset, gs_uint32_t val, struct gs_string * s2) {
+ register gs_uint8_t * st2 = (gs_uint8_t *)(s2->data);
+ register gs_uint8_t v = (unsigned char) val;
+// if ((s2->length <= offset)||(offset<0)) return 0;
+ if (s2->length <= offset) return 0;
+ return (st2[offset]==v)?1:0;
+}
+
+
+gs_retval_t str_compare( struct gs_string * str1, struct gs_string * str2)
+{
+ gs_int32_t len;
+ gs_int32_t x;
+ len = (str1->length>str2->length)?str2->length:str1->length;
+ for(x=0;x<len;x++) {
+ if (str1->data[x]>str2->data[x]) {
+ return 1;
+ }
+ if (str1->data[x]<str2->data[x]) {
+ return -1;
+ }
+ }
+
+ if (str1->length>str2->length) {
+ return 1;
+ }
+ if (str2->length>str1->length) {
+ return -1;
+ }
+ return 0;
+}
+
+gs_retval_t str_constructor(struct gs_string *s, gs_sp_t l){
+ s->data = l;
+ s->length = 0;
+ while(l[s->length] != '\0') s->length++;
+ s->owner = NULL;
+ return(0);
+}
+
+
+gs_param_handle_t register_handle_for_str_regex_match_slot_1(struct FTA * f,
+ struct gs_string* pattern) {
+ regex_t * reg;
+ if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) {
+ return 0;
+ }
+ if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) {
+ return 0;
+ }
+ return (gs_param_handle_t) reg;
+}
+
+gs_uint32_t str_regex_match(struct gs_string* str, gs_param_handle_t pattern_handle) {
+ regex_t * reg = (regex_t *) pattern_handle ;
+ gs_sp_t source = (gs_sp_t)(str->data);
+ int res;
+ static gs_sp_t d=0;
+ static gs_uint32_t dlen=0;
+ // grow our static buffer to the longest string we ever see
+ if ((str->length+1) >= dlen) {
+ if (d!=0) fta_free(0,(void*)d);
+ dlen=0;
+ d=0;
+ if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0;
+ dlen=str->length+1;
+ }
+
+ if (str->length==0) return 0;
+
+ // copy the string and 0 terminate it
+ memcpy((void *)d,(void *) str->data, str->length);
+ d[str->length]=0;
+
+ res = REG_NOMATCH;
+ res = regexec(reg, d, 0, NULL, 0);
+ return (res==REG_NOMATCH)?0:1;
+}
+
+
+gs_retval_t deregister_handle_for_str_regex_match_slot_1(gs_param_handle_t handle) {
+ regex_t * x = (regex_t *) handle;
+ regfree(x);
+ if (x!=0) fta_free(0,(void *)x);
+ return 0;
+}
+
+gs_param_handle_t register_handle_for_str_partial_regex_match_slot_1(struct FTA * f,
+ struct gs_string* pattern) {
+ regex_t * reg;
+ if ((reg=(regex_t *) fta_alloc(0,sizeof(regex_t)))==0) {
+ return 0;
+ }
+ if (regcomp(reg,(gs_sp_t)(pattern->data), REG_NEWLINE|REG_EXTENDED|REG_NOSUB)!=0) {
+ return 0;
+ }
+ return (gs_param_handle_t) reg;
+}
+
+gs_uint32_t str_partial_regex_match(struct gs_string* str,
+ gs_param_handle_t pattern_handle,
+ gs_uint32_t maxlen) {
+ regex_t * reg = (regex_t *) pattern_handle ;
+ gs_sp_t source = (gs_sp_t)(str->data);
+ gs_int32_t res;
+ gs_int32_t end;
+ static gs_sp_t d=0;
+ static gs_uint32_t dlen=0;
+ // grow our static buffer to the longest string we ever see
+ if ((str->length+1) >= dlen) {
+ if (d!=0) fta_free(0,d);
+ dlen=0;
+ d=0;
+ if ((d=(gs_sp_t)fta_alloc(0,str->length+1))==0) return 0;
+ dlen=str->length+1;
+ }
+
+ if (str->length==0) return 0;
+
+ end=(maxlen>(str->length))?(str->length):maxlen;
+
+ // copy the string and 0 terminate it
+ memcpy((void *)d,(void *) str->data, end);
+ d[str->length]=0;
+
+ /* HACK ALERT: commented out regnexec invocations to unbreak the build */
+ res = REG_NOMATCH;
+ res = regexec(reg,d, 0, NULL, 0);
+ return (res==REG_NOMATCH)?0:1;
+}
+
+
+gs_retval_t deregister_handle_for_str_partial_regex_match_slot_1(
+ gs_param_handle_t handle) {
+ regex_t * x = (regex_t *) handle;
+ regfree(x);
+ if (x!=0) fta_free(0,(void *)x);
+ return 0;
+}
+
+
+
+static gs_uint32_t nextint(struct gs_string *str , gs_uint32_t * offset, gs_uint32_t *res) {
+ gs_uint8_t * s = (gs_uint8_t *)(str->data);
+ gs_int32_t v = 0;
+ *res = 0;
+ while(*offset<str->length) {
+ if ((s[*offset]>='0') && (s[*offset]<='9')) {
+ v=1;
+ *res= (*res*10) + (gs_uint32_t) (s[*offset]-'0');
+ } else {
+ if (v!=0) { // got some valid result
+ return 1;
+ } // otherwise skip leading grabage
+ }
+ (*offset)++;
+ }
+ return v;
+}
+
+
+gs_param_handle_t register_handle_for_strtoi_c_slot_0(struct FTA * f, struct gs_string* istr) {
+ gs_uint32_t offset,r;
+ offset=0;
+ if (nextint(istr,&offset,&r)!=0)
+ return (gs_param_handle_t) r;
+ return (gs_param_handle_t) 0;
+}
+gs_retval_t deregister_handle_for_strtoi_c_slot_0(gs_param_handle_t h) {
+ return 0;
+}
+
+gs_param_handle_t register_handle_for_strtoip_c_slot_0(struct FTA * f, struct gs_string* istr) {
+ gs_uint32_t ip1,ip2,ip3,ip4,offset,r;
+ offset=0;
+ if (nextint(istr,&offset,&ip1)==0) return (gs_param_handle_t)0;
+ if (nextint(istr,&offset,&ip2)==0) return (gs_param_handle_t)0;
+ if (nextint(istr,&offset,&ip3)==0) return (gs_param_handle_t)0;
+ if (nextint(istr,&offset,&ip4)==0) return (gs_param_handle_t)0;
+ r=ip1<<24|ip2<<16|ip3<<8|ip4;
+ return (gs_param_handle_t)r;
+}
+gs_retval_t deregister_handle_for_strtoip_c_slot_0(gs_param_handle_t h) {
+ return 0;
+}
+
+
+///////////////////////////////////////////////////
+// ipv6 procedures
+
+
+
+gs_retval_t ipv6_compare( struct ipv6_str i1, struct ipv6_str i2){
+ if(i1.v[0] > i2.v[0])
+ return 1;
+ if(i1.v[0] < i2.v[0])
+ return -1;
+ if(i1.v[1] > i2.v[1])
+ return 1;
+ if(i1.v[1] < i2.v[1])
+ return -1;
+ if(i1.v[2] > i2.v[2])
+ return 1;
+ if(i1.v[2] < i2.v[2])
+ return -1;
+ if(i1.v[3] > i2.v[3])
+ return 1;
+ if(i1.v[3] < i2.v[3])
+ return -1;
+
+ return 0;
+}
+
+gs_retval_t Ipv6_Constructor(struct ipv6_str *s, gs_sp_t l){
+ gs_uint32_t i0=0,i1=0,i2=0,i3=0,i4=0,i5=0,i6=0,i7=0;
+ sscanf(l,"%x:%x:%x:%x:%x:%x:%x:%x",&i0,&i1,&i2,&i3,&i4,&i5,&i6,&i7);
+ s->v[0] = ((i0 & 0xffff) << 16) | (i1 & 0xffff);
+ s->v[1] = ((i2 & 0xffff) << 16) | (i3 & 0xffff);
+ s->v[2] = ((i4 & 0xffff) << 16) | (i5 & 0xffff);
+ s->v[3] = ((i6 & 0xffff) << 16) | (i7 & 0xffff);
+ return(0);
+}
+
+struct ipv6_str And_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){
+ struct ipv6_str ret;
+ ret.v[0] = i1.v[0] & i2.v[0];
+ ret.v[1] = i1.v[1] & i2.v[1];
+ ret.v[2] = i1.v[2] & i2.v[2];
+ ret.v[3] = i1.v[3] & i2.v[3];
+ return ret;
+}
+
+struct ipv6_str Or_Ipv6(const struct ipv6_str i1, const struct ipv6_str i2){
+ struct ipv6_str ret;
+ ret.v[0] = i1.v[0] | i2.v[0];
+ ret.v[1] = i1.v[1] | i2.v[1];
+ ret.v[2] = i1.v[2] | i2.v[2];
+ ret.v[3] = i1.v[3] | i2.v[3];
+ return ret;
+}
+struct ipv6_str hton_ipv6(struct ipv6_str s){
+ struct ipv6_str ret;
+// ret.v[0] = htonl(s.v[0]);
+// ret.v[1] = htonl(s.v[1]);
+// ret.v[2] = htonl(s.v[2]);
+// ret.v[3] = htonl(s.v[3]);
+ ret.v[0] = s.v[0];
+ ret.v[1] = s.v[1];
+ ret.v[2] = s.v[2];
+ ret.v[3] = s.v[3];
+ return ret;
+}
+
+struct ipv6_str ntoh_ipv6(struct ipv6_str s){
+ struct ipv6_str ret;
+// ret.v[0] = ntohl(s.v[0]);
+// ret.v[1] = ntohl(s.v[1]);
+// ret.v[2] = ntohl(s.v[2]);
+// ret.v[3] = ntohl(s.v[3]);
+ ret.v[0] = s.v[0];
+ ret.v[1] = s.v[1];
+ ret.v[2] = s.v[2];
+ ret.v[3] = s.v[3];
+ return ret;
+}
+
+
Code Review / com / gs-lite.git / blobdiff