From b880db8491271b4bd4aa87c2dd79b5e3c3dde6cf Mon Sep 17 00:00:00 2001 From: watcherhd Date: Thu, 17 Nov 2011 18:46:23 +0000 Subject: added: ieview, imo2sproxy, skype git-svn-id: http://miranda-plugins.googlecode.com/svn/trunk@175 e753b5eb-9565-29b2-b5c5-2cc6f99dfbcb --- imo2sproxy/src/common/cJSON.c | 365 ++++++++++++++++++++++++++++++++++++++++ imo2sproxy/src/common/cJSON.h | 97 +++++++++++ imo2sproxy/src/common/fifo.c | 144 ++++++++++++++++ imo2sproxy/src/common/fifo.h | 26 +++ imo2sproxy/src/common/memlist.c | 158 +++++++++++++++++ imo2sproxy/src/common/memlist.h | 30 ++++ 6 files changed, 820 insertions(+) create mode 100644 imo2sproxy/src/common/cJSON.c create mode 100644 imo2sproxy/src/common/cJSON.h create mode 100644 imo2sproxy/src/common/fifo.c create mode 100644 imo2sproxy/src/common/fifo.h create mode 100644 imo2sproxy/src/common/memlist.c create mode 100644 imo2sproxy/src/common/memlist.h (limited to 'imo2sproxy/src/common') diff --git a/imo2sproxy/src/common/cJSON.c b/imo2sproxy/src/common/cJSON.c new file mode 100644 index 0000000..72f35f6 --- /dev/null +++ b/imo2sproxy/src/common/cJSON.c @@ -0,0 +1,365 @@ +/* + Copyright (c) 2009 Dave Gamble + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +// cJSON +// JSON parser in C. + +#include +#include +#include +#include +#include +#include "cJSON.h" +#ifdef WIN32 +#define strcasecmp stricmp +#endif + +// Internal constructor. +static cJSON *cJSON_New_Item() { return (cJSON*)calloc(sizeof(cJSON),1); } + +// Delete a cJSON structure. +void cJSON_Delete(cJSON *c) +{ + cJSON *next; + while (c) + { + next=c->next; + if (c->child) cJSON_Delete(c->child); + if (c->valuestring) free(c->valuestring); + if (c->string) free(c->string); + free(c); + c=next; + } +} + +// Parse the input text to generate a number, and populate the result into item. +static const char *parse_number(cJSON *item,const char *num) +{ + double n=0,sign=1,scale=0;int subscale=0,signsubscale=1; + + // Could use sscanf for this? + if (*num=='-') sign=-1,num++; // Has sign? + if (*num=='0') num++; // is zero + if (*num>='1' && *num<='9') do n=(n*10.0)+(*num++ -'0'); while (*num>='0' && *num<='9'); // Number? + if (*num=='.') {num++; do n=(n*10.0)+(*num++ -'0'),scale--; while (*num>='0' && *num<='9');} // Fractional part? + if (*num=='e' || *num=='E') // Exponent? + { num++;if (*num=='+') num++; else if (*num=='-') signsubscale=-1,num++; // With sign? + while (*num>='0' && *num<='9') subscale=(subscale*10)+(*num++ - '0'); // Number? + } + + n=sign*n*pow(10.0,(scale+subscale*signsubscale)); // number = +/- number.fraction * 10^+/- exponent + + item->valuedouble=n; + item->valueint=(int)n; + item->type=cJSON_Number; + return num; +} + +// Render the number nicely from the given item into a string. +static char *print_number(cJSON *item) +{ + char *str; + double d=item->valuedouble; + if (fabs(((double)item->valueint)-d)<=DBL_EPSILON) + { + str=malloc(21); // 2^64+1 can be represented in 21 chars. + sprintf(str,"%d",item->valueint); + } + else + { + str=malloc(64); // This is a nice tradeoff. + if (fabs(d)<1.0e-6 || fabs(d)>1.0e9) sprintf(str,"%e",d); + else sprintf(str,"%f",d); + } + return str; +} + +// Parse the input text into an unescaped cstring, and populate item. +static const unsigned char firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC }; +static const char *parse_string(cJSON *item,const char *str) +{ + const unsigned char *ptr=str+1; + unsigned char *ptr2; + char *out;int len=0;unsigned uc; + if (*str!='\"') return 0; // not a string! + + while (*ptr!='\"' && *ptr>31 && ++len) if (*ptr++ == '\\') ptr++; // Skip escaped quotes. + + out=(char*)malloc(len+1); // This is how long we need for the string, roughly. + + ptr=str+1;ptr2=out; + while (*ptr!='\"' && *ptr>31) + { + if (*ptr!='\\') *ptr2++=*ptr++; + else + { + ptr++; + switch (*ptr) + { + case 'b': *ptr2++='\b'; break; + case 'f': *ptr2++='\f'; break; + case 'n': *ptr2++='\n'; break; + case 'r': *ptr2++='\r'; break; + case 't': *ptr2++='\t'; break; + case 'u': // transcode utf16 to utf8. DOES NOT SUPPORT SURROGATE PAIRS CORRECTLY. + sscanf(ptr+1,"%4x",&uc); // get the unicode char. + len=3;if (uc<0x80) len=1;else if (uc<0x800) len=2;ptr2+=len; + + switch (len) { + case 3: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; + case 2: *--ptr2 =((uc | 0x80) & 0xBF); uc >>= 6; + case 1: *--ptr2 =(uc | firstByteMark[len]); + } + ptr2+=len;ptr+=4; + break; + default: *ptr2++=*ptr; break; + } + ptr++; + } + } + *ptr2=0; + if (*ptr=='\"') ptr++; + item->valuestring=out; + item->type=cJSON_String; + return ptr; +} + +// Render the cstring provided to an escaped version that can be printed. +static char *print_string_ptr(const char *str) +{ + const unsigned char *ptr; unsigned char *ptr2,*out;int len=0; + + ptr=str;while (*ptr && ++len) {if (*ptr<32 || *ptr=='\"' || *ptr=='\\') len++;ptr++;} + + out=(char*)malloc(len+3); + ptr2=out;ptr=str; + *ptr2++='\"'; + while (*ptr) + { + if (*ptr>31 && *ptr!='\"' && *ptr!='\\') *ptr2++=*ptr++; + else + { + *ptr2++='\\'; + switch (*ptr++) + { + case '\\': *ptr2++='\\'; break; + case '\"': *ptr2++='\"'; break; + case '\b': *ptr2++='b'; break; + case '\f': *ptr2++='f'; break; + case '\n': *ptr2++='n'; break; + case '\r': *ptr2++='r'; break; + case '\t': *ptr2++='t'; break; + default: ptr2--; break; // eviscerate with prejudice. + } + } + } + *ptr2++='\"';*ptr2++=0; + return out; +} +// Invote print_string_ptr (which is useful) on an item. +static char *print_string(cJSON *item) {return print_string_ptr(item->valuestring);} + +// Predeclare these prototypes. +static const char *parse_value(cJSON *item,const char *value); +static char *print_value(cJSON *item,int depth); +static const char *parse_array(cJSON *item,const char *value); +static char *print_array(cJSON *item,int depth); +static const char *parse_object(cJSON *item,const char *value); +static char *print_object(cJSON *item,int depth); + +// Parse an object - create a new root, and populate. +cJSON *cJSON_Parse(const char *value) {cJSON *c=cJSON_New_Item();parse_value(c,value);return c;} +// Render a cJSON item/entity/structure to text. +char *cJSON_Print(cJSON *item) {return print_value(item,0);} + +// Parser core - when encountering text, process appropriately. +static const char *parse_value(cJSON *item,const char *value) +{ + if (!value) return 0; // Fail on null. + if (!strncmp(value,"null",4)) { item->type=cJSON_NULL; return value+4; } + if (!strncmp(value,"false",5)) { item->type=cJSON_False; return value+5; } + if (!strncmp(value,"true",4)) { item->type=cJSON_True; item->valueint=1; return value+4; } + if (*value=='\"') { return parse_string(item,value); } + if (*value=='-' || (*value>='0' && *value<='9')) { return parse_number(item,value); } + if (*value=='[') { return parse_array(item,value); } + if (*value=='{') { return parse_object(item,value); } + + return 0; // failure. +} + +// Render a value to text. +static char *print_value(cJSON *item,int depth) +{ + char *out=0; + switch (item->type) + { + case cJSON_NULL: out=strdup("null"); break; + case cJSON_False: out=strdup("false");break; + case cJSON_True: out=strdup("true"); break; + case cJSON_Number: out=print_number(item);break; + case cJSON_String: out=print_string(item);break; + case cJSON_Array: out=print_array(item,depth);break; + case cJSON_Object: out=print_object(item,depth);break; + } + return out; +} + +// Utility to jump whitespace and cr/lf +static const char *skip(const char *in) {while (in && *in<=32) in++; return in;} + +// Build an array from input text. +static const char *parse_array(cJSON *item,const char *value) +{ + cJSON *child; + if (*value!='[') return 0; // not an array! + + item->type=cJSON_Array; + value=skip(value+1); + if (*value==']') return value+1; // empty array. + + item->child=child=cJSON_New_Item(); + value=skip(parse_value(child,skip(value))); // skip any spacing, get the value. + + while (*value==',') + { + cJSON *new_item; + if (!(new_item=cJSON_New_Item())) return 0; // memory fail + child->next=new_item;new_item->prev=child;child=new_item; + value=skip(parse_value(child,skip(value+1))); + } + + if (*value==']') return value+1; // end of array + return 0; // malformed. +} + +// Render an array to text +static char *print_array(cJSON *item,int depth) +{ + char *out,*ptr,*ret;int len=5; + cJSON *child=item->child; + + out=malloc(len);*out='['; + ptr=out+1;*ptr=0; + while (child) + { + ret=print_value(child,depth+1); + if (!ret) {free(out);return 0;} // Check for failure! + len+=strlen(ret)+3; + out=realloc(out,len); + ptr=out+strlen(out); + ptr+=sprintf(ptr,"%s",ret); + if (child->next) {*ptr++=',';*ptr++=' ';*ptr=0;} + child=child->next; + free(ret); + } + *ptr++=']';*ptr++=0; + return out; +} + +// Build an object from the text. +static const char *parse_object(cJSON *item,const char *value) +{ + cJSON *child; + if (*value!='{') return 0; // not an object! + + item->type=cJSON_Object; + value=skip(value+1); + if (*value=='}') return value+1; // empty array. + + item->child=child=cJSON_New_Item(); + value=skip(parse_string(child,skip(value))); + child->string=child->valuestring;child->valuestring=0; + if (*value!=':') return 0; // fail! + value=skip(parse_value(child,skip(value+1))); // skip any spacing, get the value. + + while (*value==',') + { + cJSON *new_item; + if (!(new_item=cJSON_New_Item())) return 0; // memory fail + child->next=new_item;new_item->prev=child;child=new_item; + value=skip(parse_string(child,skip(value+1))); + child->string=child->valuestring;child->valuestring=0; + if (*value!=':') return 0; // fail! + value=skip(parse_value(child,skip(value+1))); // skip any spacing, get the value. + } + + if (*value=='}') return value+1; // end of array + return 0; // malformed. +} + +// Render an object to text. +static char *print_object(cJSON *item,int depth) +{ + char *out,*ptr,*ret,*str;int len=7;//,i; + cJSON *child=item->child; + + depth++;out=malloc(len+depth);*out='{'; + ptr=out+1;*ptr++=' ';*ptr=0; + while (child) + { + str=print_string_ptr(child->string); + if (!str) {free(out);return 0;} + ret=print_value(child,depth); + if (!ret) {free(out);return 0;} // Check for failure! + len+=strlen(ret)+strlen(str)+4+depth; + out=realloc(out,len); + ptr=out+strlen(out); +// for (i=0;inext) *ptr++=','; + *ptr++=' ';*ptr=0; + child=child->next; + free(str);free(ret); + } +// for (i=0;ichild;int i=0;while(c)i++,c=c->next;return i;} +cJSON *cJSON_GetArrayItem(cJSON *array,int item) {cJSON *c=array->child; while (c && item) item--,c=c->next; return c;} +cJSON *cJSON_GetObjectItem(cJSON *object,const char *string) {cJSON *c=object->child; while (c && strcasecmp(c->string,string)) c=c->next; return c;} + +// Utility for array list handling. +static void suffix_object(cJSON *prev,cJSON *item) {prev->next=item;item->prev=prev;} + +// Add item to array/object. +void cJSON_AddItemToArray(cJSON *array, cJSON *item) {cJSON *c=array->child;if (!c) {array->child=item;} else {while (c && c->next) c=c->next; suffix_object(c,item);}} +void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item) {if (item->string) free(item->string);item->string=strdup(string);cJSON_AddItemToArray(object,item);} + +// Create basic types: +cJSON *cJSON_CreateNull() {cJSON *item=cJSON_New_Item();item->type=cJSON_NULL;return item;} +cJSON *cJSON_CreateTrue() {cJSON *item=cJSON_New_Item();item->type=cJSON_True;return item;} +cJSON *cJSON_CreateFalse() {cJSON *item=cJSON_New_Item();item->type=cJSON_False;return item;} +cJSON *cJSON_CreateNumber(double num) {cJSON *item=cJSON_New_Item();item->type=cJSON_Number;item->valuedouble=num;item->valueint=(int)num;return item;} +cJSON *cJSON_CreateString(const char *string) {cJSON *item=cJSON_New_Item();item->type=cJSON_String;item->valuestring=strdup(string);return item;} +cJSON *cJSON_CreateArray() {cJSON *item=cJSON_New_Item();item->type=cJSON_Array;return item;} +cJSON *cJSON_CreateObject() {cJSON *item=cJSON_New_Item();item->type=cJSON_Object;return item;} + +// Create Arrays: +cJSON *cJSON_CreateIntArray(int *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateFloatArray(float *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateDoubleArray(double *numbers,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;ichild=n;else suffix_object(p,n);p=n;}return a;} +cJSON *cJSON_CreateStringArray(const char **strings,int count) {int i;cJSON *n=0,*p=0,*a=cJSON_CreateArray();for(i=0;ichild=n;else suffix_object(p,n);p=n;}return a;} diff --git a/imo2sproxy/src/common/cJSON.h b/imo2sproxy/src/common/cJSON.h new file mode 100644 index 0000000..debda45 --- /dev/null +++ b/imo2sproxy/src/common/cJSON.h @@ -0,0 +1,97 @@ +/* + Copyright (c) 2009 Dave Gamble + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +// cJSON Types: +#define cJSON_False 0 +#define cJSON_True 1 +#define cJSON_NULL 2 +#define cJSON_Number 3 +#define cJSON_String 4 +#define cJSON_Array 5 +#define cJSON_Object 6 + +// The cJSON structure: +typedef struct cJSON { + struct cJSON *next,*prev; // next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem + struct cJSON *child; // An array or object item will have a child pointer pointing to a chain of the items in the array/object. + + int type; // The type of the item, as above. + + char *valuestring; // The item's string, if type==cJSON_String + int valueint; // The item's number, if type==cJSON_Number + double valuedouble; // The item's number, if type==cJSON_Number + + char *string; // The item's name string, if this item is the child of, or is in the list of subitems of an object. +} cJSON; + +// Supply a block of JSON, and this returns a cJSON object you can interrogate. Call cJSON_Delete when finished. +extern cJSON *cJSON_Parse(const char *value); +// Render a cJSON entity to text for transfer/storage. Free the char* when finished. +extern char *cJSON_Print(cJSON *item); +// Delete a cJSON entity and all subentities. +extern void cJSON_Delete(cJSON *c); + +// Returns the number of items in an array (or object). +extern int cJSON_GetArraySize(cJSON *array); +// Retrieve item number "item" from array "array". Returns NULL if unsuccessful. +extern cJSON *cJSON_GetArrayItem(cJSON *array,int item); +// Get item "string" from object. Case insensitive. +extern cJSON *cJSON_GetObjectItem(cJSON *object,const char *string); + +// These calls create a cJSON item of the appropriate type. +extern cJSON *cJSON_CreateNull(); +extern cJSON *cJSON_CreateTrue(); +extern cJSON *cJSON_CreateFalse(); +extern cJSON *cJSON_CreateNumber(double num); +extern cJSON *cJSON_CreateString(const char *string); +extern cJSON *cJSON_CreateArray(); +extern cJSON *cJSON_CreateObject(); + +// These utilities create an Array of count items. +extern cJSON *cJSON_CreateIntArray(int *numbers,int count); +extern cJSON *cJSON_CreateFloatArray(float *numbers,int count); +extern cJSON *cJSON_CreateDoubleArray(double *numbers,int count); +extern cJSON *cJSON_CreateStringArray(const char **strings,int count); + +// Append item to the specified array/object. +extern void cJSON_AddItemToArray(cJSON *array, cJSON *item); +extern void cJSON_AddItemToObject(cJSON *object,const char *string,cJSON *item); + +#define cJSON_AddNullToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateNull()) +#define cJSON_AddTrueToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateTrue()) +#define cJSON_AddFalseToObject(object,name) cJSON_AddItemToObject(object, name, cJSON_CreateFalse()) +#define cJSON_AddNumberToObject(object,name,n) cJSON_AddItemToObject(object, name, cJSON_CreateNumber(n)) +#define cJSON_AddStringToObject(object,name,s) cJSON_AddItemToObject(object, name, cJSON_CreateString(s)) + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/imo2sproxy/src/common/fifo.c b/imo2sproxy/src/common/fifo.c new file mode 100644 index 0000000..d703ac3 --- /dev/null +++ b/imo2sproxy/src/common/fifo.c @@ -0,0 +1,144 @@ +#include +#include +#include "fifo.h" + +struct _tagFIFO +{ + unsigned int uiCount; + unsigned int uiCapacity; + unsigned int uiActInd; + char *acStorage; +}; + + +TYP_FIFO *Fifo_Init(unsigned int uiCapacity) +{ + TYP_FIFO *pstHandle; + + pstHandle = (TYP_FIFO *)malloc(sizeof(TYP_FIFO)); + if (!pstHandle) return NULL; + pstHandle->uiCount = pstHandle->uiActInd = 0; + pstHandle->uiCapacity = uiCapacity; + if (uiCapacity == 0) + pstHandle->acStorage = NULL; + else + { + pstHandle->acStorage = (char *)malloc(uiCapacity); + if (!pstHandle->acStorage) + { + free (pstHandle); + return NULL; + } + } + return pstHandle; +} + +void Fifo_Exit(TYP_FIFO *pstHandle) +{ + if (pstHandle->acStorage) + free (pstHandle->acStorage); + free (pstHandle); +} + +char *Fifo_AllocBuffer(TYP_FIFO *pstHandle, unsigned int uiPCount) +{ + unsigned int uiCount = pstHandle->uiCount; + + if (!Fifo_Add (pstHandle, NULL, uiPCount)) return NULL; + return &pstHandle->acStorage[pstHandle->uiActInd+uiCount]; + +} + +BOOL Fifo_Add(TYP_FIFO *pstHandle, char *acPBytes, unsigned int uiPCount) +{ + unsigned int uiFree; + + if (uiPCount == 0) return TRUE; + if (pstHandle->uiCapacity == 0) + { + if (!(pstHandle->acStorage = (char *)calloc(1, uiPCount))) + return FALSE; + if (acPBytes) + memcpy(pstHandle->acStorage, acPBytes, uiPCount); + else + memset(pstHandle->acStorage, 0, uiPCount); + pstHandle->uiCapacity = pstHandle->uiCount = uiPCount; + pstHandle->uiActInd = 0; + } + else + { + uiFree = pstHandle->uiCapacity-(pstHandle->uiActInd+pstHandle->uiCount); + if (uiFree < uiPCount) + { + if (pstHandle->uiActInd>=uiPCount && pstHandle->uiActInd*4>pstHandle->uiCount) + { + memmove(pstHandle->acStorage, pstHandle->acStorage+pstHandle->uiActInd, pstHandle->uiCount); + pstHandle->uiActInd = 0; + } + else + { + char *acBuf; + unsigned int uiNewLen; + + if (pstHandle->uiCapacity*2 < + pstHandle->uiCount+pstHandle->uiActInd+uiPCount) + uiNewLen = pstHandle->uiCount+pstHandle->uiActInd+uiPCount; + else + uiNewLen = pstHandle->uiCapacity*2; + acBuf = realloc(pstHandle->acStorage, uiNewLen); + if (acBuf == NULL) return FALSE; + pstHandle->acStorage = acBuf; + memset (acBuf+pstHandle->uiCapacity, 0, uiNewLen-pstHandle->uiCapacity); + pstHandle->uiCapacity = uiNewLen; + } + } + if (acPBytes) + memcpy (&pstHandle->acStorage[pstHandle->uiActInd+pstHandle->uiCount], acPBytes, uiPCount); + else + memset (&pstHandle->acStorage[pstHandle->uiActInd+pstHandle->uiCount], 0, uiPCount); + + pstHandle->uiCount += uiPCount; + } + + return TRUE; +} + +BOOL Fifo_AddString(TYP_FIFO *pstHandle, char *pszString) +{ + BOOL bRet; + + while (pstHandle->uiCount && pstHandle->acStorage[pstHandle->uiCount+pstHandle->uiActInd-1]==0) + pstHandle->uiCount--; + bRet = Fifo_Add (pstHandle, pszString, strlen(pszString)+1); + return bRet; +} + +char *Fifo_Get (TYP_FIFO *pstHandle, unsigned int *uiPCount) +{ + unsigned int uiCount; + char *pRet; + + if (!uiPCount) uiCount = pstHandle->uiCount; + else + { + if (pstHandle->uiCount < *uiPCount) + *uiPCount = pstHandle->uiCount; + uiCount = *uiPCount; + } + if (!uiCount) return NULL; + + pRet = &pstHandle->acStorage[pstHandle->uiActInd]; + pstHandle->uiActInd += uiCount; + pstHandle->uiCount -= uiCount; + return pRet; +} + +void Fifo_Reset (TYP_FIFO *pstHandle) +{ + pstHandle->uiCount = pstHandle->uiActInd = 0; +} + +unsigned int Fifo_Count (TYP_FIFO *pstHandle) +{ + return pstHandle->uiCount; +} diff --git a/imo2sproxy/src/common/fifo.h b/imo2sproxy/src/common/fifo.h new file mode 100644 index 0000000..0ab9f4f --- /dev/null +++ b/imo2sproxy/src/common/fifo.h @@ -0,0 +1,26 @@ +#ifndef __FIFO_H__ +#define __FIFO_H__ + +struct _tagFIFO; +typedef struct _tagFIFO TYP_FIFO; + +#ifndef BOOL +#define BOOL int +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif + +TYP_FIFO *Fifo_Init(unsigned int uiCapacity); +void Fifo_Exit(TYP_FIFO *pstHandle); +char *Fifo_AllocBuffer(TYP_FIFO *pstHandle, unsigned int uiPCount); +BOOL Fifo_Add(TYP_FIFO *pstHandle, char *acPBytes, unsigned int uiPCount); +BOOL Fifo_AddString(TYP_FIFO *pstHandle, char *pszString); +char *Fifo_Get (TYP_FIFO *pstHandle, unsigned int *uiPCount); +unsigned int Fifo_Count (TYP_FIFO *pstHandle); +void Fifo_Reset (TYP_FIFO *hFifo); + +#endif diff --git a/imo2sproxy/src/common/memlist.c b/imo2sproxy/src/common/memlist.c new file mode 100644 index 0000000..137a03e --- /dev/null +++ b/imo2sproxy/src/common/memlist.c @@ -0,0 +1,158 @@ +#include "memlist.h" +#include +#include + +struct _tagLIST +{ + unsigned int uiCount; + unsigned int uiCapacity; + void **apStorage; +}; + +// ----------------------------------------------------------------------------- +// Interface +// ----------------------------------------------------------------------------- + +TYP_LIST *List_Init(unsigned int uiCapacity) +{ + TYP_LIST *pstHandle; + + pstHandle = (TYP_LIST *)malloc(sizeof(TYP_LIST)); + + if (!pstHandle) return NULL; + pstHandle->uiCount = 0; + pstHandle->uiCapacity = uiCapacity; + if (uiCapacity == 0) + pstHandle->apStorage = NULL; + else + { + pstHandle->apStorage = (void **)malloc(sizeof(void *)*uiCapacity); + if (!pstHandle->apStorage) + { + free(pstHandle); + return NULL; + } + } + return pstHandle; +} + +// ----------------------------------------------------------------------------- + +void List_Exit(TYP_LIST *pstHandle) +{ + if (pstHandle->apStorage) + free (pstHandle->apStorage); + free (pstHandle); +} + +// ----------------------------------------------------------------------------- + +BOOL List_Push(TYP_LIST *pstHandle, void *pItem) +{ + return List_InsertElementAt(pstHandle, pItem,pstHandle->uiCount); +} + +// ----------------------------------------------------------------------------- + +void *List_Pop (TYP_LIST *pstHandle) +{ + if (pstHandle->uiCount) + return List_RemoveElementAt(pstHandle ,pstHandle->uiCount-1); + else return NULL; +} + +// ----------------------------------------------------------------------------- + +BOOL List_ReplaceElementAt(TYP_LIST *pstHandle, void *pItem, unsigned int uiPos) +{ + if (uiPos >= pstHandle->uiCount) return NULL; + pstHandle->apStorage[uiPos]=pItem; + return TRUE; +} + +// ----------------------------------------------------------------------------- + +BOOL List_InsertElementAt(TYP_LIST *pstHandle, void *pItem, unsigned int uiPos) +{ + unsigned int uiStep; + void **apNewStorage; + + if (uiPos > pstHandle->uiCount) + uiPos = pstHandle->uiCount; + + if (pstHandle->uiCount >= pstHandle->uiCapacity) + { + uiStep = pstHandle->uiCount*2; + if (uiStep < 8) uiStep = 8; + + if (!pstHandle->apStorage) + apNewStorage = (void **)malloc(sizeof(void *)*uiStep); + else + apNewStorage = realloc (pstHandle->apStorage, sizeof(void *)*uiStep); + if (!apNewStorage) return FALSE; + pstHandle->apStorage = apNewStorage; + pstHandle->uiCapacity = uiStep; + } + + if (uiPosuiCount) + memmove(&pstHandle->apStorage[uiPos+1], &pstHandle->apStorage[uiPos], (pstHandle->uiCount-uiPos)*sizeof(void*)); + pstHandle->apStorage[uiPos] = pItem; + pstHandle->uiCount++; + return TRUE; +} + +// ----------------------------------------------------------------------------- + +void *List_RemoveElementAt(TYP_LIST *pstHandle, unsigned int uiPos) +{ + void *pRet; + + pRet = pstHandle->apStorage[uiPos]; + if (uiPosuiCount-1) + memmove (&pstHandle->apStorage[uiPos], &pstHandle->apStorage[uiPos+1], (pstHandle->uiCount-uiPos-1)*sizeof(void*)); + pstHandle->uiCount--; + return pRet; +} + +// ----------------------------------------------------------------------------- + +unsigned int List_Count(TYP_LIST *pstHandle) +{ + return pstHandle->uiCount; +} + +// ----------------------------------------------------------------------------- + +void *List_ElementAt(TYP_LIST *pstHandle,unsigned int uiPos) +{ + if (uiPos >= pstHandle->uiCount) return NULL; + return pstHandle->apStorage[uiPos]; +} + +// ----------------------------------------------------------------------------- + +void *List_Top(TYP_LIST *pstHandle) +{ + if (pstHandle->uiCount) + return List_ElementAt (pstHandle, pstHandle->uiCount-1); + else return NULL; +} + +// ----------------------------------------------------------------------------- + +void List_Sort(TYP_LIST *pstHandle, int (*pFunc)(const void*,const void*)) +{ + qsort(pstHandle->apStorage,pstHandle->uiCount,sizeof(void *),pFunc); +} + +// ----------------------------------------------------------------------------- + +void List_FreeElements(TYP_LIST *pstHandle) +{ + void *pEntry; + + while (pEntry = List_Pop(pstHandle)) + free (pEntry); +} + +// ----------------------------------------------------------------------------- diff --git a/imo2sproxy/src/common/memlist.h b/imo2sproxy/src/common/memlist.h new file mode 100644 index 0000000..be37bbb --- /dev/null +++ b/imo2sproxy/src/common/memlist.h @@ -0,0 +1,30 @@ +#ifndef __LIST_H__ +#define __LIST_H__ + +#ifndef BOOL +#define BOOL int +#endif +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif + +struct _tagLIST; +typedef struct _tagLIST TYP_LIST; + +TYP_LIST *List_Init(unsigned int uiCapacity); +void List_Exit(TYP_LIST *pstHandle); +BOOL List_Push(TYP_LIST *pstHandle, void *pItem); +void *List_Pop (TYP_LIST *pstHandle); +BOOL List_ReplaceElementAt(TYP_LIST *pstHandle, void *pItem, unsigned int uiPos); +BOOL List_InsertElementAt(TYP_LIST *pstHandle, void *pItem, unsigned int uiPos); +void *List_RemoveElementAt(TYP_LIST *pstHandle, unsigned int uiPos); +unsigned int List_Count(TYP_LIST *pstHandle); +void *List_ElementAt(TYP_LIST *pstHandle,unsigned int uiPos); +void *List_Top(TYP_LIST *pstHandle); +void List_FreeElements(TYP_LIST *pstHandle); +void List_Sort(TYP_LIST *pstHandle, int (*pFunc)(const void*,const void*)); + +#endif -- cgit v1.2.3