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       28901 : 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       28901 :         size_t l=0;
      10       28901 :         char *rpath=NULL;
      11             : 
      12       28901 :         l+=plen;
      13       28901 :         l+=flen;
      14       28901 :         l+=slen;
      15       28901 :         l+=1;
      16             : 
      17       28901 :         if(!(rpath=(char *)malloc_w(l, __func__)))
      18           0 :                 return NULL;
      19       28901 :         if(plen) memcpy(rpath,           prep,  plen);
      20       28901 :         if(slen) memcpy(rpath+plen,      sep,   slen);
      21       28901 :         if(flen) memcpy(rpath+plen+slen, fname, flen);
      22       28901 :         rpath[plen+slen+flen]='\0';
      23             : 
      24       28901 :         if(newlen) (*newlen)+=slen+flen;
      25       28901 :         return rpath;
      26             : }
      27             : 
      28       28901 : 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       28901 :                 sep, (sep && *fname)?strlen(sep):0, NULL);
      34             : }
      35             : 
      36        1151 : char *prepend(const char *prep, const char *fname)
      37             : {
      38        1151 :         return prepend_n(prep, fname, strlen(fname), "");
      39             : }
      40             : 
      41       27688 : char *prepend_slash(const char *prep, const char *fname, size_t len)
      42             : {
      43       27688 :         if(!prep || !*prep)
      44           2 :                 return strdup_w(fname, __func__);
      45             :         // Try to avoid getting a double slash in the path.
      46       27686 :         if(fname && fname[0]=='/')
      47             :         {
      48        7298 :                 fname++;
      49        7298 :                 len--;
      50             :         }
      51       27686 :         return prepend_n(prep, fname, len, "/");
      52             : }
      53             : 
      54       27680 : char *prepend_s(const char *prep, const char *fname)
      55             : {
      56       27680 :         return prepend_slash(prep, fname, strlen(fname));
      57             : }
      58             : 
      59       90480 : int astrcat(char **buf, const char *append, const char *func)
      60             : {
      61       90480 :         int l=0;
      62       90480 :         char *copy=NULL;
      63       90480 :         if(append) l+=strlen(append);
      64       90480 :         if(*buf) l+=strlen(*buf);
      65       90480 :         l++;
      66      167960 :         if((*buf && !(copy=strdup_w(*buf, __func__)))
      67      180960 :           || !(*buf=(char *)realloc_w(*buf, l, __func__)))
      68             :         {
      69           0 :                 log_oom_w(__func__, func);
      70           0 :                 return -1;
      71             :         }
      72       90480 :         snprintf(*buf, l, "%s%s", copy?copy:"", append?append:"");
      73       90480 :         free_w(&copy);
      74       90480 :         return 0;
      75             : }