Line data    Source code

       1             : #include "burp.h"
       2             : #include "alloc.h"
       3             : #include "log.h"
       4             : 
       5             : /* This may be given binary data, of which we need to already know the length */
       6       31861 : char *prepend_len(const char *prep, size_t plen, const char *fname,
       7             :         size_t flen, const char *sep, size_t slen, size_t *newlen)
       8             : {
       9       31861 :         size_t l=0;
      10       31861 :         char *rpath=NULL;
      11             : 
      12       31861 :         l+=plen;
      13       31861 :         l+=flen;
      14       31861 :         l+=slen;
      15       31861 :         l+=1;
      16             : 
      17       31861 :         if(!(rpath=(char *)malloc_w(l, __func__)))
      18             :                 return NULL;
      19       31861 :         if(plen) memcpy(rpath,           prep,  plen);
      20       31861 :         if(slen) memcpy(rpath+plen,      sep,   slen);
      21       31861 :         if(flen) memcpy(rpath+plen+slen, fname, flen);
      22       31861 :         rpath[plen+slen+flen]='\0';
      23             : 
      24       31861 :         if(newlen) (*newlen)+=slen+flen;
      25       31861 :         return rpath;
      26             : }
      27             : 
      28       31853 : char *prepend_n(const char *prep, const char *fname,
      29             :         size_t len, const char *sep)
      30             : {
      31             :         return prepend_len(prep, prep?strlen(prep):0,
      32             :                 fname, len,
      33       31853 :                 sep, (sep && *fname)?strlen(sep):0, NULL);
      34             : }
      35             : 
      36        1281 : char *prepend(const char *prep, const char *fname)
      37             : {
      38        1281 :         return prepend_n(prep, fname, strlen(fname), "");
      39             : }
      40             : 
      41       30541 : char *prepend_slash(const char *prep, const char *fname, size_t len)
      42             : {
      43       30541 :         if(!prep || !*prep)
      44          38 :                 return strdup_w(fname, __func__);
      45             :         // Try to avoid getting a double slash in the path.
      46       30503 :         if(fname && fname[0]=='/')
      47             :         {
      48        7314 :                 fname++;
      49        7314 :                 len--;
      50             :         }
      51       30503 :         return prepend_n(prep, fname, len, "/");
      52             : }
      53             : 
      54       30521 : char *prepend_s(const char *prep, const char *fname)
      55             : {
      56       30521 :         return prepend_slash(prep, fname, strlen(fname));
      57             : }
      58             : 
      59      327660 : int astrcat(char **buf, const char *append, const char *func)
      60             : {
      61      327660 :         int l=0;
      62      327660 :         char *copy=NULL;
      63      327660 :         if(append) l+=strlen(append);
      64      327660 :         if(*buf) l+=strlen(*buf);
      65      327660 :         l++;
      66      608348 :         if((*buf && !(copy=strdup_w(*buf, __func__)))
      67      655320 :           || !(*buf=(char *)realloc_w(*buf, l, __func__)))
      68             :         {
      69           0 :                 log_oom_w(__func__, func);
      70           0 :                 return -1;
      71             :         }
      72      327660 :         snprintf(*buf, l, "%s%s", copy?copy:"", append?append:"");
      73      327660 :         free_w(&copy);
      74      327660 :         return 0;
      75             : }