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

Diff for /libaitio/src/Attic/tools.c between versions 1.12.2.1 and 1.17

version 1.12.2.1, 2012/05/15 23:09:24 version 1.17, 2012/08/01 00:37:08
Line 123  io_UnquotStr(char * __restrict psLine) Line 123  io_UnquotStr(char * __restrict psLine)
                 return 0;                  return 0;
   
         if (*psLine == '"' || *psLine == '\'') {          if (*psLine == '"' || *psLine == '\'') {
                str = strdup(psLine + 1);                str = io_strdup(psLine + 1);
                 for (pos = str, flg = 0; *pos; flg = ('\\' == *pos), pos++) {                  for (pos = str, flg = 0; *pos; flg = ('\\' == *pos), pos++) {
                         if (!flg && *pos == *psLine) {                          if (!flg && *pos == *psLine) {
                                 *pos = 0;                                  *pos = 0;
Line 131  io_UnquotStr(char * __restrict psLine) Line 131  io_UnquotStr(char * __restrict psLine)
                                 break;                                  break;
                         }                          }
                 }                  }
                free(str);                io_free(str);
                 return 1;                  return 1;
         }          }
   
Line 143  io_UnquotStr(char * __restrict psLine) Line 143  io_UnquotStr(char * __restrict psLine)
  *   *
  * @psLine = Text string   * @psLine = Text string
  * @lineLen = Length of Text string   * @lineLen = Length of Text string
 * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be free) * return: NULL nothing to do or error; !=0 Allocated new converted data without term\0 (must be io_free)
 */  */
 inline u_char *  inline u_char *
 io_Ch2Hex(u_char *psLine, int lineLen)  io_Ch2Hex(u_char *psLine, int lineLen)
Line 155  io_Ch2Hex(u_char *psLine, int lineLen) Line 155  io_Ch2Hex(u_char *psLine, int lineLen)
         if (!psLine || !*psLine || !lineLen)          if (!psLine || !*psLine || !lineLen)
                 return NULL;                  return NULL;
   
        str = malloc(lineLen / 2);        str = io_malloc(lineLen / 2);
         if (!str) {          if (!str) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 176  io_Ch2Hex(u_char *psLine, int lineLen) Line 176  io_Ch2Hex(u_char *psLine, int lineLen)
  *   *
  * @psLine = Text string   * @psLine = Text string
  * @lineLen = Length of Text string   * @lineLen = Length of Text string
 * return: NULL nothing to do or error; !=0 Allocated new converted string(must be free) * return: NULL nothing to do or error; !=0 Allocated new converted string(must be io_free)
 */  */
 inline char *  inline char *
 io_Hex2Ch(u_char *psLine, int lineLen)  io_Hex2Ch(u_char *psLine, int lineLen)
Line 187  io_Hex2Ch(u_char *psLine, int lineLen) Line 187  io_Hex2Ch(u_char *psLine, int lineLen)
         if (!psLine || !*psLine || !lineLen)          if (!psLine || !*psLine || !lineLen)
                 return NULL;                  return NULL;
   
        str = malloc(lineLen * 2 + 1);        str = io_malloc(lineLen * 2 + 1);
         if (!str) {          if (!str) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 207  io_Hex2Ch(u_char *psLine, int lineLen) Line 207  io_Hex2Ch(u_char *psLine, int lineLen)
  * io_CopyEnv() - Copy environment to new environment array;   * io_CopyEnv() - Copy environment to new environment array;
  *   *
  * @oldenv = Environment array   * @oldenv = Environment array
 * return: NULL error; !=NULL Allocated new environment array(must be free) * return: NULL error; !=NULL Allocated new environment array(must be io_free)
 */  */
 char **  char **
 io_CopyEnv(const char **oldenv)  io_CopyEnv(const char **oldenv)
Line 226  io_CopyEnv(const char **oldenv) Line 226  io_CopyEnv(const char **oldenv)
                         num++;                          num++;
   
         /* create and copy new environment */          /* create and copy new environment */
        newenv = calloc(num + 1, sizeof(char*));        newenv = io_calloc(num + 1, sizeof(char*));
         if (!newenv) {          if (!newenv) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
Line 235  io_CopyEnv(const char **oldenv) Line 235  io_CopyEnv(const char **oldenv)
   
         for (i = 0; oldenv[i]; i++)          for (i = 0; oldenv[i]; i++)
                 if (*strchr(oldenv[i], '=')) {                  if (*strchr(oldenv[i], '=')) {
                        *el = strdup(oldenv[i]);                        *el = io_strdup(oldenv[i]);
                         el++;                          el++;
                 }                  }
         *el = NULL;          *el = NULL;
Line 248  io_CopyEnv(const char **oldenv) Line 248  io_CopyEnv(const char **oldenv)
  *   *
  * @psProg = Program name for execute   * @psProg = Program name for execute
  * @oldarg = Arguments array   * @oldarg = Arguments array
 * return: NULL error; !=NULL Allocated execution array(must be free) * return: NULL error; !=NULL Allocated execution array(must be io_free)
 */  */
 char **  char **
 io_ExecArgs(const char *psProg, const char **oldarg)  io_ExecArgs(const char *psProg, const char **oldarg)
Line 265  io_ExecArgs(const char *psProg, const char **oldarg) Line 265  io_ExecArgs(const char *psProg, const char **oldarg)
         for (num = 0; oldarg[num]; num++);          for (num = 0; oldarg[num]; num++);
   
         /* create and copy new arguments */          /* create and copy new arguments */
        newarg = calloc(num + 2, sizeof(char*));        newarg = io_calloc(num + 2, sizeof(char*));
         if (!newarg) {          if (!newarg) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         } else          } else
                 el = newarg;                  el = newarg;
   
        *el = strdup(psProg);        *el = io_strdup(psProg);
         el++;          el++;
   
         for (i = 0; oldarg[i]; i++, el++)          for (i = 0; oldarg[i]; i++, el++)
                *el = strdup(oldarg[i]);                *el = io_strdup(oldarg[i]);
         *el = NULL;          *el = NULL;
   
         return newarg;          return newarg;
Line 296  io_FreeNullTerm(char *** __restrict arr) Line 296  io_FreeNullTerm(char *** __restrict arr)
         if (arr && *arr) {          if (arr && *arr) {
                 a = *arr;                  a = *arr;
                 while (a && *a)                  while (a && *a)
                        free(*a++);                        io_free(*a++);
                free(*arr);                io_free(*arr);
                 *arr = NULL;                  *arr = NULL;
         }          }
 }  }
   
 /*  /*
    * io_argsNum() Parse and calculate number of arguments
    *
    * @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_argsNum(const char *csArgs, const char *csDelim)
   {
           register int res;
           char *pos;
   
           assert(csArgs);
           assert(csDelim);
           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
   */
   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 = io_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);
           }
   
           io_free(psBuf);
           return ret;
   }
   
   /*
    * io_MakeAV2() Parse and make attribute/value pair over input string
    *
    * @csArgs = Input argument line, will be modified!
    * @csDelim = Delimiter for separate
    * @psAttr = Output Attribute
    * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
    * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
   */
   int
   io_MakeAV2(char * __restrict psArgs, const char *csDelim, 
                   char ** __restrict psAttr, char ** __restrict psValue)
   {
           register int ret = 0;
           char *pos;
   
           if (!psArgs || !csDelim)
                   return -1;
   
           pos = strpbrk(psArgs, csDelim);
           if (pos) {
                   *pos++ = 0;
                   ret++;
                   if (psAttr)
                           *psAttr = psArgs;
           } else
                   return 0;
   
           if (psValue) {
                   if (pos && *pos) {
                           ret++;
                           *psValue = pos;
                   } else
                           *psValue = NULL;
           }
   
           return ret;
   }
   
   /*
  * io_Path2File() - Parse and make path/filename pair   * io_Path2File() - Parse and make path/filename pair
  *   *
  * @csArgs = Input argument line   * @csArgs = Input argument line
Line 323  io_Path2File(const char * __restrict csArgs, char * __ Line 430  io_Path2File(const char * __restrict csArgs, char * __
         if (psPath && !pathLen)          if (psPath && !pathLen)
                 return -1;                  return -1;
   
        psBuf = strdup(csArgs);        psBuf = io_strdup(csArgs);
         if (!psBuf) {          if (!psBuf) {
                 LOGERR;                  LOGERR;
                 return -1;                  return -1;
Line 333  io_Path2File(const char * __restrict csArgs, char * __ Line 440  io_Path2File(const char * __restrict csArgs, char * __
         if (!pos) {          if (!pos) {
                 strlcpy(psFile, psBuf, fileLen);                  strlcpy(psFile, psBuf, fileLen);
   
                free(psBuf);                io_free(psBuf);
                 return 1;                  return 1;
         } else          } else
                 *pos++ = 0;                  *pos++ = 0;
Line 342  io_Path2File(const char * __restrict csArgs, char * __ Line 449  io_Path2File(const char * __restrict csArgs, char * __
         if (psPath)          if (psPath)
                 strlcpy(psPath, psBuf, pathLen);                  strlcpy(psPath, psBuf, pathLen);
   
        free(psBuf);        io_free(psBuf);
         return 2;          return 2;
 }  }
   
Line 442  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t * Line 549  io_n2addr(io_sockaddr_t * __restrict addr, ait_val_t *
         if (!addr || !val)          if (!addr || !val)
                 return ret;                  return ret;
   
           AIT_INIT_VAL(val);
         switch (addr->sa.sa_family) {          switch (addr->sa.sa_family) {
                 case AF_INET:                  case AF_INET:
                         if (!inet_ntop(AF_INET, &addr->sin.sin_addr, str, INET_ADDRSTRLEN)) {                          if (!inet_ntop(AF_INET, &addr->sin.sin_addr, str, INET_ADDRSTRLEN)) {
Line 485  io_gethostbyname(const char *psHost, u_short port, io_ Line 593  io_gethostbyname(const char *psHost, u_short port, io_
   
         if (!psHost || !addr)          if (!psHost || !addr)
                 return NULL;                  return NULL;
         else  
                 memset(addr, 0, sizeof(io_sockaddr_t));  
   
         if (*psHost != '/') {          if (*psHost != '/') {
                 /* resolver */                  /* resolver */
Line 497  io_gethostbyname(const char *psHost, u_short port, io_ Line 603  io_gethostbyname(const char *psHost, u_short port, io_
                 if (!host) {                  if (!host) {
                         io_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));                          io_SetErr(EINVAL, "Resolver #%d - %s", h_errno, hstrerror(h_errno));
                         return NULL;                          return NULL;
                } else                } else {
                         memset(addr, 0, sizeof(io_sockaddr_t));
                         addr->sa.sa_family = host->h_addrtype;                          addr->sa.sa_family = host->h_addrtype;
        } else                }
         } else {
                 memset(addr, 0, sizeof(io_sockaddr_t));
                 addr->sa.sa_family = AF_LOCAL;                  addr->sa.sa_family = AF_LOCAL;
           }
                   
   
         switch (addr->sa.sa_family) {          switch (addr->sa.sa_family) {
                 case AF_INET:                  case AF_INET:
Removed from v.1.12.2.1  
changed lines
  Added in v.1.17

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