[BACK]Return to url.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/Attic/url.c between versions 1.1.2.2 and 1.3.6.2

version 1.1.2.2, 2010/03/02 16:45:23 version 1.3.6.2, 2010/09/28 07:38:19
Line 16 Line 16
  * return: 0 error format not find tech:// and return URL like path;    * return: 0 error format not find tech:// and return URL like path; 
                 -1 error:: can`t read; >0 ok, up bits for known elements                  -1 error:: can`t read; >0 ok, up bits for known elements
 */  */
int ioURLGet(const char *csURL, struct tagIOURL *url)int
 ioURLGet(const char *csURL, struct tagIOURL *url)
 {  {
         char *pos, *at, *cl, *sl;          char *pos, *at, *cl, *sl;
         int ret = 0;          int ret = 0;
Line 115  int ioURLGet(const char *csURL, struct tagIOURL *url) Line 116  int ioURLGet(const char *csURL, struct tagIOURL *url)
 }  }
   
 /*  /*
 * io_MakeArray() Parse and make array of arguments values * io_MakeArray() Parse and make array of arguments values ... 
 * @psArgs = Input arguments line ... (will be destroed after procced function!) *      (input string will be modified! and output array must be free)
  * @psArgs = Input arguments line, after execute string is modified!!!
  * @csDelim = Delimiter(s) for separate   * @csDelim = Delimiter(s) for separate
 * @args = Output array of arguments * @args = Output array of arguments ... (must be free() after procced function!)
 * @nargs = Requested count of arguments * @nargs = Maximum requested count of arguments from input string psArgs
  * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items   * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
 */  */
int io_MakeArray(char * __restrict psArgs, const char *csDelim, char *** __restrict args, int nargs)inline int
 io_MakeArray(char * __restrict psArgs, const char *csDelim, char *** __restrict args, int nargs)
 {  {
         char **app;          char **app;
         register int i;          register int i;
   
        if (!psArgs || !args || !nargs)        if (!psArgs || !csDelim || !args || !nargs)
                 return -1;                  return -1;
         if (!(*args = malloc(sizeof(char*) * nargs))) {          if (!(*args = malloc(sizeof(char*) * nargs))) {
                 LOGERR;                  LOGERR;
Line 138  int io_MakeArray(char * __restrict psArgs, const char  Line 141  int io_MakeArray(char * __restrict psArgs, const char 
         for (i = 0, app = *args; app < *args + nargs && (*app = strsep(&psArgs, csDelim));           for (i = 0, app = *args; app < *args + nargs && (*app = strsep(&psArgs, csDelim)); 
                                 **app ? i++ : i, **app ? app++ : app);                                  **app ? i++ : i, **app ? app++ : app);
         return i;          return i;
   }
   /*
    * io_SizeArray() Parse and calculate size of array
    * @csArgs = Input arguments line
    * @csDelim = Delimiter(s) for separate
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
   */
   inline int
   io_SizeArray(const char *csArgs, const char *csDelim)
   {
           register int res;
           char *pos;
   
           if (!csArgs || !csDelim)
                   return -1;
   
           for (res = 1, pos = (char*) csArgs; (pos = strpbrk(pos, csDelim)); res++, pos++);
           return res;
   }
   /*
    * io_MakeAV() Parse and make attribute/value pair
    * @csArgs = Input argument line
    * @csDelim = Delimiter for separate
    * @psAttr = Output Attribute
    * @attrLen = Size of attribute array
    * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
    * @valLen = Size of value array
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
   */
   inline int
   io_MakeAV(const char * __restrict csArgs, const char *csDelim, 
                   char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen)
   {
           register int ret = 0;
           char *pos, *psBuf;
   
           if (!csArgs || !csDelim || !psAttr || !attrLen)
                   return -1;
           if (psValue && !valLen)
                   return -1;
           else
                   memset(psValue, 0, valLen);
           psBuf = strdup(csArgs);
           if (!psBuf) {
                   LOGERR;
                   return -1;
           }
   
           pos = strpbrk(psBuf, csDelim);
           if (pos)
                   *pos++ = 0;
           ret++;
           strlcpy(psAttr, psBuf, attrLen);
   
           if (pos && *pos) {
                   ret++;
                   if (psValue)
                           strlcpy(psValue, pos, valLen);
           }
   
           free(psBuf);
           return ret;
   }
   
   /*
    * io_Path2File() Parse and make path/filename pair
    * @csArgs = Input argument line
    * @psPath = Output Path, if ==NULL path not returned
    * @pathLen = Size of path array
    * @psFile = Output File
    * @fileLen = Size of file array
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
   */
   inline int
   io_Path2File(const char * __restrict csArgs, char * __restrict psPath, int pathLen, 
                   char * __restrict psFile, int fileLen)
   {
           char *pos, *psBuf;
   
           if (!csArgs || !psFile || !fileLen)
                   return -1;
           if (psPath && !pathLen)
                   return -1;
           else
                   memset(psPath, 0, pathLen);
           psBuf = strdup(csArgs);
           if (!psBuf) {
                   LOGERR;
                   return -1;
           }
   
           pos = strrchr(psBuf, '/');
           if (!pos) {
                   strlcpy(psFile, psBuf, fileLen);
   
                   free(psBuf);
                   return 1;
           } else
                   *pos++ = 0;
   
           strlcpy(psFile, pos, fileLen);
           if (psPath)
                   strlcpy(psPath, psBuf, pathLen);
   
           free(psBuf);
           return 2;
   }
   
   /*
    * ioURLGetValue() Get value from parsed URL
    * @url = Input parsed URL
    * @csAttr = Attribute for search
    * @psValue = Return value of attribute, if ==NULL only check for existence of attribute
    * @valLen = Size of psValue array
    * return: 0 error attribute not find; -1 error:: can`t read; >0 ok, find at position
   */
   int
   ioURLGetValue(struct tagIOURL *url, const char *csAttr, char * __restrict psValue, int valLen)
   {
           register int i, ret = 0;
           char szBuf[BUFSIZ], **items, szElem[2][BUFSIZ];
           int len;
   
           if (!url || !csAttr)
                   return -1;
   
           strlcpy(szBuf, url->url_args.value, BUFSIZ);
           if (io_MakeArray(szBuf, "&", &items, (len = io_SizeArray(szBuf, "&"))) < 1)
                   return ret;
   
           for (i = 0; i < len && items[i]; i++) {
                   if (io_MakeAV(items[i], "=", szElem[0], BUFSIZ, szElem[1], BUFSIZ) < 1)
                           continue;
   
                   if (!strcmp(szElem[0], csAttr)) {
                           ret = i + 1;
                           if (psValue && valLen)
                                   strlcpy(psValue, szElem[1], valLen);
                           break;
                   }
           }
   
           free(items);
           return ret;
   }
   
   /*
    * ioURLGetFile() Get file from parsed URL
    * @url = Input parsed URL
    * @psValue = Return filename, if not specified file in url path, replace with /
    * @valLen = Size of psValue array
    * return: -1 error:: can`t read; 0 ok
   */
   int
   ioURLGetFile(struct tagIOURL *url, char * __restrict psValue, int valLen)
   {
           if (!url || !psValue || !valLen)
                   return -1;
   
           if (io_Path2File(url->url_path.value, NULL, 0, psValue, valLen) < 1)
                   return -1;
   
           // If not specified file in path, default replace to /
           if (!*psValue)
                   strlcpy(psValue, "/", valLen);
           return 0;
   }
   
   // ------------------------------------------
   
   /*
    * ioXMLGet() Parse and get data from input XML request string [ns:]container[|attribute[=value]][?data]
    * @csXML = Input XML request line
    * @xml = Output parsed XML request
    * return: 0 error format incorrect, -1 error:: can`t read; >0 ok readed elements bits
   */
   int
   ioXMLGet(const char *csXML, struct tagReqXML *xml)
   {
           char *pos, *p, *end;
           int ret = 0;
   
           if (!csXML || !xml)
                   return -1;
           else
                   memset(xml, 0, sizeof *xml);
   
           strlcpy((char*) xml->xml_line, csXML, BUFSIZ);
           // if namespace present
           if ((pos = strchr((char*) xml->xml_line, ':'))) {
                   xml->xml_namespace.value = (char*) xml->xml_line;
                   xml->xml_namespace.vallen = pos - (char*) xml->xml_line;
                   if (xml->xml_namespace.vallen)
                           ret |= 1;
                   *pos++ = 0;
           } else
                   pos = (char*) xml->xml_line;
           // if container is path
           if (*pos == '/') {
                   xml->xml_node.path.value = pos;
                   xml->xml_node.path.vallen = strlen(pos);
                   if (!xml->xml_node.path.vallen)
                           ret = 0;
                   else
                           ret |= 32;
                   return ret;
           } else {
           // container
                   xml->xml_node.container.value = pos;
                   xml->xml_node.container.vallen = strlen(pos);
                   if (!xml->xml_node.container.vallen)
                           return 0;
                   else
                           ret |= 2;
           }
           end = strchr(pos, '?');
           // if attribute present
           if (pos && (p = strchr(pos, '|')) && (!end || end > p)) {
                   pos = p;
                   *pos++ = 0;
                   xml->xml_node.container.vallen = strlen(xml->xml_node.container.value);
                   if (!xml->xml_node.container.vallen)
                           return 0;
   
                   xml->xml_attribute.value = pos;
                   xml->xml_attribute.vallen = strlen(pos);
                   if (xml->xml_attribute.vallen)
                           ret |= 4;
           }
           // if value present
           if (pos && (p = strchr(pos, '=')) && (!end || end > p)) {
                   if (!(ret & 4))
                           return 0;
                   else
                           pos = p;
                   *pos++ = 0;
                   xml->xml_attribute.vallen = strlen(xml->xml_attribute.value);
                   if (!xml->xml_attribute.vallen)
                           return 0;
   
                   xml->xml_value.value = pos;
                   xml->xml_value.vallen = strlen(pos);
                   if (xml->xml_value.vallen)
                           ret |= 8;
           }
           // if data present
           if (pos && end) {
                   if (ret < 2)
                           return 0;
                   else
                           pos = end;
                   *pos++ = 0;
                   if (ret & 8) {
                           xml->xml_value.vallen = strlen(xml->xml_value.value);
                           if (!xml->xml_value.vallen)
                                   return 0;
                   } else if (ret & 4) {
                           xml->xml_attribute.vallen = strlen(xml->xml_attribute.value);
                           if (!xml->xml_attribute.vallen)
                                   return 0;
                   } else if (ret & 2) {
                           xml->xml_node.container.vallen = strlen(xml->xml_node.container.value);
                           if (!xml->xml_node.container.vallen)
                                   return 0;
                   } else
                           return 0;
   
                   xml->xml_data.value = pos;
                   xml->xml_data.vallen = strlen(pos);
                   if (xml->xml_data.vallen)
                           ret |= 16;
           }
   
           return ret;
 }  }
Removed from v.1.1.2.2  
changed lines
  Added in v.1.3.6.2

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>