-/* ------------------------------------------------
-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;
-}
-
-
+/* ------------------------------------------------\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
Code Review / com / gs-lite.git / blobdiff