Changeset 14633


Ignore:
Timestamp:
Dec 25, 2015, 10:19:50 AM (5 years ago)
Author:
mikedld
Message:

Ongoing refactoring (use size_t instead of int)

Location:
trunk
Files:
19 edited

Legend:

Unmodified
Added
Removed
  • trunk/daemon/remote.c

    r14615 r14633  
    578578      int * values;
    579579
    580       values = tr_parseNumberRange (arg, -1, &valueCount);
     580      values = tr_parseNumberRange (arg, TR_BAD_SIZE, &valueCount);
    581581      for (i=0; i<valueCount; ++i)
    582582        {
     
    616616      int i;
    617617      int valueCount;
    618       int * values = tr_parseNumberRange (arg, -1, &valueCount);
     618      int * values = tr_parseNumberRange (arg, TR_BAD_SIZE, &valueCount);
    619619
    620620      for (i=0; i<valueCount; ++i)
  • trunk/gtk/tr-prefs.c

    r14525 r14633  
    502502{
    503503  gchar * url = gtk_editable_get_chars (e, 0, -1);
    504   const gboolean err = tr_urlParse (url, -1, NULL, NULL, NULL, NULL);
     504  const gboolean err = tr_urlParse (url, TR_BAD_SIZE, NULL, NULL, NULL, NULL);
    505505  gtk_widget_set_sensitive (GTK_WIDGET (gbutton), !err);
    506506  g_free (url);
  • trunk/libtransmission/ConvertUTF.c

    r13625 r14633  
    4444#endif
    4545#include <string.h> /* strlen () */
     46
     47#include "transmission.h"
     48
    4649#include "ConvertUTF.h"
    4750
     
    351354 */
    352355Boolean
    353 tr_utf8_validate (const char * str, int max_len, const char ** end)
     356tr_utf8_validate (const char * str, size_t max_len, const char ** end)
    354357{
    355358    const UTF8* source = (const UTF8*) str;
     
    362365        return false;
    363366
    364     sourceEnd = source + ((max_len < 0) ? strlen (str) : (size_t)max_len);
     367    sourceEnd = source + (max_len == TR_BAD_SIZE ? strlen (str) : max_len);
    365368
    366369    if (source == sourceEnd)
     
    391394        }
    392395    }
    393 
    394    
    395396}
    396397
  • trunk/libtransmission/ConvertUTF.h

    r13625 r14633  
    152152
    153153/* intended to work the same as g_utf8_validate */
    154 Boolean tr_utf8_validate (const char * str, int max_len, const char ** end);
     154Boolean tr_utf8_validate (const char * str, size_t max_len, const char ** end);
    155155
    156156
  • trunk/libtransmission/announcer-udp.c

    r14521 r14633  
    764764
    765765    /* see if we've already got a tracker that matches this host + port */
    766     tr_urlParse (url, -1, NULL, &host, &port, NULL);
     766    tr_urlParse (url, TR_BAD_SIZE, NULL, &host, &port, NULL);
    767767    key = tr_strdup_printf ("%s:%d", host, port);
    768768    for (i=0, n=tr_ptrArraySize (&tau->trackers); !tracker && i<n; ++i) {
  • trunk/libtransmission/announcer.c

    r14619 r14633  
    230230    int port = 0;
    231231
    232     tr_urlParse (url, -1, &scheme, &host, &port, NULL);
     232    tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, NULL);
    233233    ret = tr_strdup_printf ("%s://%s:%d", (scheme?scheme:"invalid"), (host?host:"invalid"), port);
    234234
     
    584584            char * path;
    585585            bool is_duplicate = false;
    586             tr_urlParse (input[i].announce, -1, &scheme, &host, &port, &path);
     586            tr_urlParse (input[i].announce, TR_BAD_SIZE, &scheme, &host, &port, &path);
    587587
    588588            /* weed out one common source of duplicates:
  • trunk/libtransmission/platform.c

    r14532 r14633  
    554554                  {
    555555                    if ((end - tmp) > 1)
    556                       tr_list_append (&candidates, tr_strndup (tmp, end - tmp));
     556                      tr_list_append (&candidates, tr_strndup (tmp, (size_t) (end - tmp)));
    557557                    tmp = (char *) end + 1;
    558558                  }
  • trunk/libtransmission/rpc-server.c

    r14552 r14633  
    131131{
    132132  char * headers;
    133   int headers_len;
     133  size_t headers_len;
    134134  char * body;
    135   int body_len;
     135  size_t body_len;
    136136};
    137137
     
    177177            {
    178178              struct tr_mimepart * p = tr_new (struct tr_mimepart, 1);
    179               p->headers_len = rnrn - part;
     179              p->headers_len = (size_t) (rnrn - part);
    180180              p->headers = tr_strndup (part, p->headers_len);
    181               p->body_len = (part+part_len) - (rnrn + 4);
     181              p->body_len = (size_t) ((part + part_len) - (rnrn + 4));
    182182              p->body = tr_strndup (rnrn+4, p->body_len);
    183183              tr_ptrArrayAppend (setme_parts, p);
     
    222222          const struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
    223223          const char * ours = get_current_session_id (server);
    224           const int ourlen = strlen (ours);
     224          const size_t ourlen = strlen (ours);
    225225          hasSessionId = ourlen<=p->body_len && !memcmp (p->body, ours, ourlen);
    226226        }
     
    238238        {
    239239          struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
    240           int body_len = p->body_len;
     240          size_t body_len = p->body_len;
    241241          tr_variant top, *args;
    242242          tr_variant test;
     
    564564      data->req = req;
    565565      data->server = server;
    566       tr_rpc_request_exec_uri (server->session, q+1, -1, rpc_response_func, data);
     566      tr_rpc_request_exec_uri (server->session, q + 1, TR_BAD_SIZE, rpc_response_func, data);
    567567    }
    568568  else
  • trunk/libtransmission/rpc-test.c

    r14552 r14633  
    2323  tr_variant top;
    2424
    25   tr_rpc_parse_list_str (&top, "12", -1);
     25  tr_rpc_parse_list_str (&top, "12", TR_BAD_SIZE);
    2626  check (tr_variantIsInt (&top));
    2727  check (tr_variantGetInt (&top, &i));
     
    3535  tr_variantFree (&top);
    3636
    37   tr_rpc_parse_list_str (&top, "6,7", -1);
     37  tr_rpc_parse_list_str (&top, "6,7", TR_BAD_SIZE);
    3838  check (tr_variantIsList (&top));
    3939  check (tr_variantListSize (&top) == 2);
     
    4444  tr_variantFree (&top);
    4545
    46   tr_rpc_parse_list_str (&top, "asdf", -1);
     46  tr_rpc_parse_list_str (&top, "asdf", TR_BAD_SIZE);
    4747  check (tr_variantIsString (&top));
    4848  check (tr_variantGetStr (&top, &str, &len));
     
    5151  tr_variantFree (&top);
    5252
    53   tr_rpc_parse_list_str (&top, "1,3-5", -1);
     53  tr_rpc_parse_list_str (&top, "1,3-5", TR_BAD_SIZE);
    5454  check (tr_variantIsList (&top));
    5555  check (tr_variantListSize (&top) == 4);
  • trunk/libtransmission/rpcimpl.c

    r14594 r14633  
    23002300tr_rpc_parse_list_str (tr_variant  * setme,
    23012301                       const char  * str,
    2302                        int           len)
     2302                       size_t        len)
    23032303
    23042304{
     
    23302330tr_rpc_request_exec_uri (tr_session           * session,
    23312331                         const void           * request_uri,
    2332                          int                    request_len,
     2332                         size_t                 request_uri_len,
    23332333                         tr_rpc_response_func   callback,
    23342334                         void                 * callback_user_data)
     
    23372337  tr_variant top;
    23382338  tr_variant * args;
    2339   char * request = tr_strndup (request_uri, request_len);
     2339  char * request = tr_strndup (request_uri, request_uri_len);
    23402340
    23412341  tr_variantInitDict (&top, 3);
     
    23502350      if (delim)
    23512351        {
    2352           char * key = tr_strndup (pch, delim - pch);
     2352          char * key = tr_strndup (pch, (size_t) (delim - pch));
    23532353          int isArg = strcmp (key, "method") && strcmp (key, "tag");
    23542354          tr_variant * parent = isArg ? args : &top;
    23552355
    2356           tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, delim-pch)),
     2356          tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, (size_t) (delim - pch))),
    23572357                                 delim + 1,
    23582358                                 next ? (size_t)(next - (delim + 1)) : strlen (delim + 1));
  • trunk/libtransmission/rpcimpl.h

    r14552 r14633  
    3535void tr_rpc_request_exec_uri (tr_session           * session,
    3636                              const void           * request_uri,
    37                               int                    request_len,
     37                              size_t                 request_uri_len,
    3838                              tr_rpc_response_func   callback,
    3939                              void                 * callback_user_data);
     
    4141void tr_rpc_parse_list_str (tr_variant  * setme,
    4242                            const char  * list_str,
    43                             int           list_str_len);
     43                            size_t        list_str_len);
    4444
    4545#ifdef __cplusplus
  • trunk/libtransmission/transmission.h

    r14612 r14633  
    9090#define SHA_DIGEST_LENGTH 20
    9191#define TR_INET6_ADDRSTRLEN 46
     92 
     93#define TR_BAD_SIZE ((size_t) -1)
    9294
    9395typedef uint32_t tr_file_index_t;
  • trunk/libtransmission/utils-test.c

    r14606 r14633  
    106106
    107107  in = "hello world";
    108   out = tr_utf8clean (in, -1);
     108  out = tr_utf8clean (in, TR_BAD_SIZE);
    109109  check_streq (in, out);
    110110  tr_free (out);
     
    120120  check (out != NULL);
    121121  check ((strlen (out) == 17) || (strlen (out) == 33));
    122   check (tr_utf8_validate (out, -1, NULL));
     122  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
    123123  tr_free (out);
    124124
    125125  /* same string, but utf-8 clean */
    126126  in = "ТруЎМП быть БПгПЌ";
    127   out = tr_utf8clean (in, -1);
     127  out = tr_utf8clean (in, TR_BAD_SIZE);
    128128  check (out != NULL);
    129   check (tr_utf8_validate (out, -1, NULL));
     129  check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
    130130  check_streq (in, out);
    131131  tr_free (out);
     
    141141  int * numbers;
    142142
    143   numbers = tr_parseNumberRange ("1-10,13,16-19", -1, &count);
     143  numbers = tr_parseNumberRange ("1-10,13,16-19", TR_BAD_SIZE, &count);
    144144  check_int_eq (15, count);
    145145  check_int_eq (1, numbers[0]);
     
    151151  tr_free (numbers);
    152152
    153   numbers = tr_parseNumberRange ("1-5,3-7,2-6", -1, &count);
     153  numbers = tr_parseNumberRange ("1-5,3-7,2-6", TR_BAD_SIZE, &count);
    154154  check (count == 7);
    155155  check (numbers != NULL);
     
    158158  tr_free (numbers);
    159159
    160   numbers = tr_parseNumberRange ("1-Hello", -1, &count);
     160  numbers = tr_parseNumberRange ("1-Hello", TR_BAD_SIZE, &count);
    161161  check_int_eq (0, count);
    162162  check (numbers == NULL);
    163163
    164   numbers = tr_parseNumberRange ("1-", -1, &count);
     164  numbers = tr_parseNumberRange ("1-", TR_BAD_SIZE, &count);
    165165  check_int_eq (0, count);
    166166  check (numbers == NULL);
    167167
    168   numbers = tr_parseNumberRange ("Hello", -1, &count);
     168  numbers = tr_parseNumberRange ("Hello", TR_BAD_SIZE, &count);
    169169  check_int_eq (0, count);
    170170  check (numbers == NULL);
     
    318318
    319319  url = "http://1";
    320   check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     320  check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
    321321  check_streq ("http", scheme);
    322322  check_streq ("1", host);
     
    328328
    329329  url = "http://www.some-tracker.org/some/path";
    330   check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     330  check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
    331331  check_streq ("http", scheme);
    332332  check_streq ("www.some-tracker.org", host);
     
    338338
    339339  url = "http://www.some-tracker.org:80/some/path";
    340   check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
     340  check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
    341341  check_streq ("http", scheme);
    342342  check_streq ("www.some-tracker.org", host);
  • trunk/libtransmission/utils.c

    r14619 r14633  
    366366tr_strdup (const void * in)
    367367{
    368   return tr_strndup (in, in ? (int)strlen ((const char *)in) : 0);
     368  return tr_strndup (in, in != NULL ? strlen (in) : 0);
    369369}
    370370
    371371char*
    372 tr_strndup (const void * in, int len)
     372tr_strndup (const void * in, size_t len)
    373373{
    374374  char * out = NULL;
    375375
    376   if (len < 0)
     376  if (len == TR_BAD_SIZE)
    377377    {
    378378      out = tr_strdup (in);
     
    672672
    673673static bool
    674 isValidURLChars (const char * url, int url_len)
     674isValidURLChars (const char * url, size_t url_len)
    675675{
    676676  const char * c;
     
    707707  else
    708708    {
    709       const int len = strlen (url);
     709      const size_t len = strlen (url);
    710710
    711711      valid = isValidURLChars (url, len)
     
    719719/** @brief return true if the URL is a http or https or ftp or sftp one that Transmission understands */
    720720bool
    721 tr_urlIsValid (const char * url, int url_len)
     721tr_urlIsValid (const char * url, size_t url_len)
    722722{
    723723  bool valid;
     
    729729  else
    730730    {
    731       if (url_len < 0)
     731      if (url_len == TR_BAD_SIZE)
    732732        url_len = strlen (url);
    733733
     
    749749int
    750750tr_urlParse (const char * url_in,
    751              int          len,
     751             size_t       len,
    752752             char **      setme_protocol,
    753753             char **      setme_host,
     
    757757  int err;
    758758  int port = 0;
    759   int n;
     759  size_t n;
    760760  char * tmp;
    761761  char * pch;
     
    771771      *pch = '\0';
    772772      protocol = tmp;
    773       protocol_len = pch - protocol;
     773      protocol_len = (size_t) (pch - protocol);
    774774      pch += 3;
    775775      if ((n = strcspn (pch, ":/")))
     
    10421042
    10431043char*
    1044 tr_utf8clean (const char * str, int max_len)
     1044tr_utf8clean (const char * str, size_t max_len)
    10451045{
    10461046  char * ret;
    10471047  const char * end;
    10481048
    1049   if (max_len < 0)
    1050     max_len = (int) strlen (str);
     1049  if (max_len == TR_BAD_SIZE)
     1050    max_len = strlen (str);
    10511051
    10521052  if (tr_utf8_validate (str, max_len, &end))
     
    10551055    ret = to_utf8 (str, max_len);
    10561056
    1057   assert (tr_utf8_validate (ret, -1, NULL));
     1057  assert (tr_utf8_validate (ret, TR_BAD_SIZE, NULL));
    10581058  return ret;
    10591059}
     
    12351235 */
    12361236static bool
    1237 parseNumberSection (const char * str, int len, struct number_range * setme)
     1237parseNumberSection (const char * str, size_t len, struct number_range * setme)
    12381238{
    12391239  long a, b;
     
    12901290 */
    12911291int*
    1292 tr_parseNumberRange (const char * str_in, int len, int * setmeCount)
     1292tr_parseNumberRange (const char * str_in, size_t len, int * setmeCount)
    12931293{
    12941294  int n = 0;
     
    13061306      if (pch)
    13071307        {
    1308           success = parseNumberSection (walk, pch-walk, &range);
     1308          success = parseNumberSection (walk, (size_t) (pch - walk), &range);
    13091309          walk = pch + 1;
    13101310        }
  • trunk/libtransmission/utils.h

    r14619 r14633  
    191191 * @param len the length of the string to copy. If -1, the entire string is used.
    192192 */
    193 char* tr_utf8clean (const char * str, int len) TR_GNUC_MALLOC;
     193char* tr_utf8clean (const char * str, size_t len) TR_GNUC_MALLOC;
    194194
    195195#ifdef _WIN32
     
    284284 * @return a newly-allocated copy of `in' that can be freed with tr_free ()
    285285 */
    286 char* tr_strndup (const void * in, int len) TR_GNUC_MALLOC;
     286char* tr_strndup (const void * in, size_t len) TR_GNUC_MALLOC;
    287287
    288288/**
     
    364364
    365365/** @brief return true if the url is a [ http, https, ftp, ftps ] url that Transmission understands */
    366 bool tr_urlIsValid (const char * url, int url_len) TR_GNUC_NONNULL (1);
     366bool tr_urlIsValid (const char * url, size_t url_len) TR_GNUC_NONNULL (1);
    367367
    368368/** @brief parse a URL into its component parts
    369369    @return zero on success or an error number if an error occurred */
    370370int  tr_urlParse (const char * url,
    371                   int          url_len,
     371                  size_t       url_len,
    372372                  char      ** setme_scheme,
    373373                  char      ** setme_host,
     
    389389 */
    390390int* tr_parseNumberRange (const char * str,
    391                           int str_len,
    392                           int * setmeCount) TR_GNUC_MALLOC TR_GNUC_NONNULL (1);
     391                          size_t      str_len,
     392                          int        * setmeCount) TR_GNUC_MALLOC TR_GNUC_NONNULL (1);
    393393
    394394
  • trunk/libtransmission/variant.c

    r14619 r14633  
    188188tr_variant_string_set_string (struct tr_variant_string  * str,
    189189                              const char                * bytes,
    190                               int                         len)
     190                              size_t                      len)
    191191{
    192192  tr_variant_string_clear (str);
     
    194194  if (bytes == NULL)
    195195    len = 0;
    196   else if (len < 0)
     196  else if (len == TR_BAD_SIZE)
    197197    len = strlen (bytes);
    198198
    199   if ((size_t)len < sizeof(str->str.buf))
     199  if (len < sizeof (str->str.buf))
    200200    {
    201201      str->type = TR_STRING_TYPE_BUF;
     
    477477
    478478void
    479 tr_variantInitStr (tr_variant * v, const void * str, int len)
     479tr_variantInitStr (tr_variant * v, const void * str, size_t len)
    480480{
    481481  tr_variantInit (v, TR_VARIANT_TYPE_STR);
     
    599599{
    600600  tr_variant * child = tr_variantListAdd (list);
    601   tr_variantInitStr (child, val, -1);
     601  tr_variantInitStr (child, val, TR_BAD_SIZE);
    602602  return child;
    603603}
     
    728728{
    729729  tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_STR);
    730   tr_variantInitStr (child, val, -1);
     730  tr_variantInitStr (child, val, TR_BAD_SIZE);
    731731  return child;
    732732}
  • trunk/libtransmission/variant.h

    r14491 r14633  
    207207void         tr_variantInitStr         (tr_variant       * initme,
    208208                                        const void       * str,
    209                                         int                str_len);
     209                                        size_t             str_len);
    210210
    211211void         tr_variantInitQuark       (tr_variant       * initme,
  • trunk/qt/TrackerDelegate.cc

    r14554 r14633  
    194194  char * host = NULL;
    195195  int port = 0;
    196   tr_urlParse (inf.st.announce.toUtf8().constData(), -1, NULL, &host, &port, NULL);
     196  tr_urlParse (inf.st.announce.toUtf8().constData(), TR_BAD_SIZE, NULL, &host, &port, NULL);
    197197  str += QString::fromLatin1 ("%1:%2").arg (QString::fromUtf8 (host)).arg (port);
    198198  tr_free (host);
  • trunk/utils/edit.c

    r14619 r14633  
    212212                  printf ("\tReplaced in \"announce-list\" tier %d: \"%s\" --> \"%s\"\n", tierCount, str, newstr);
    213213                  tr_variantFree (node);
    214                   tr_variantInitStr (node, newstr, -1);
     214                  tr_variantInitStr (node, newstr, TR_BAD_SIZE);
    215215                  tr_free (newstr);
    216216                  changed = true;
Note: See TracChangeset for help on using the changeset viewer.