Line data    Source code

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