int valueCount;
int * values;
- values = tr_parseNumberRange (arg, -1, &valueCount);
+ values = tr_parseNumberRange (arg, TR_BAD_SIZE, &valueCount);
for (i=0; i<valueCount; ++i)
{
if (values[i] < 0 || values[i] > 7)
{
int i;
int valueCount;
- int * values = tr_parseNumberRange (arg, -1, &valueCount);
+ int * values = tr_parseNumberRange (arg, TR_BAD_SIZE, &valueCount);
for (i=0; i<valueCount; ++i)
tr_variantListAddInt (files, values[i]);
on_blocklist_url_changed (GtkEditable * e, gpointer gbutton)
{
gchar * url = gtk_editable_get_chars (e, 0, -1);
- const gboolean err = tr_urlParse (url, -1, NULL, NULL, NULL, NULL);
+ const gboolean err = tr_urlParse (url, TR_BAD_SIZE, NULL, NULL, NULL, NULL);
gtk_widget_set_sensitive (GTK_WIDGET (gbutton), !err);
g_free (url);
}
#include <stdio.h>
#endif
#include <string.h> /* strlen () */
+
+#include "transmission.h"
+
#include "ConvertUTF.h"
static const int halfShift = 10; /* used for shifting by 10 bits */
* In addition to knowing if the sequence is legal, it also tells you the last good character.
*/
Boolean
-tr_utf8_validate (const char * str, int max_len, const char ** end)
+tr_utf8_validate (const char * str, size_t max_len, const char ** end)
{
const UTF8* source = (const UTF8*) str;
const UTF8* sourceEnd;
if (str == NULL)
return false;
- sourceEnd = source + ((max_len < 0) ? strlen (str) : (size_t)max_len);
+ sourceEnd = source + (max_len == TR_BAD_SIZE ? strlen (str) : max_len);
if (source == sourceEnd)
{
return true;
}
}
-
-
}
/* intended to work the same as g_utf8_validate */
-Boolean tr_utf8_validate (const char * str, int max_len, const char ** end);
+Boolean tr_utf8_validate (const char * str, size_t max_len, const char ** end);
#ifdef __cplusplus
struct tau_tracker * tracker = NULL;
/* see if we've already got a tracker that matches this host + port */
- tr_urlParse (url, -1, NULL, &host, &port, NULL);
+ tr_urlParse (url, TR_BAD_SIZE, NULL, &host, &port, NULL);
key = tr_strdup_printf ("%s:%d", host, port);
for (i=0, n=tr_ptrArraySize (&tau->trackers); !tracker && i<n; ++i) {
struct tau_tracker * tmp = tr_ptrArrayNth (&tau->trackers, i);
char * host = NULL;
int port = 0;
- tr_urlParse (url, -1, &scheme, &host, &port, NULL);
+ tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, NULL);
ret = tr_strdup_printf ("%s://%s:%d", (scheme?scheme:"invalid"), (host?host:"invalid"), port);
tr_free (host);
char * host;
char * path;
bool is_duplicate = false;
- tr_urlParse (input[i].announce, -1, &scheme, &host, &port, &path);
+ tr_urlParse (input[i].announce, TR_BAD_SIZE, &scheme, &host, &port, &path);
/* weed out one common source of duplicates:
* "http://tracker/announce" +
if (end)
{
if ((end - tmp) > 1)
- tr_list_append (&candidates, tr_strndup (tmp, end - tmp));
+ tr_list_append (&candidates, tr_strndup (tmp, (size_t) (end - tmp)));
tmp = (char *) end + 1;
}
else if (tmp && *tmp)
struct tr_mimepart
{
char * headers;
- int headers_len;
+ size_t headers_len;
char * body;
- int body_len;
+ size_t body_len;
};
static void
if (rnrn)
{
struct tr_mimepart * p = tr_new (struct tr_mimepart, 1);
- p->headers_len = rnrn - part;
+ p->headers_len = (size_t) (rnrn - part);
p->headers = tr_strndup (part, p->headers_len);
- p->body_len = (part+part_len) - (rnrn + 4);
+ p->body_len = (size_t) ((part + part_len) - (rnrn + 4));
p->body = tr_strndup (rnrn+4, p->body_len);
tr_ptrArrayAppend (setme_parts, p);
}
{
const struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
const char * ours = get_current_session_id (server);
- const int ourlen = strlen (ours);
+ const size_t ourlen = strlen (ours);
hasSessionId = ourlen<=p->body_len && !memcmp (p->body, ours, ourlen);
}
else for (i=0; i<n; ++i)
{
struct tr_mimepart * p = tr_ptrArrayNth (&parts, i);
- int body_len = p->body_len;
+ size_t body_len = p->body_len;
tr_variant top, *args;
tr_variant test;
bool have_source = false;
struct rpc_response_data * data = tr_new0 (struct rpc_response_data, 1);
data->req = req;
data->server = server;
- tr_rpc_request_exec_uri (server->session, q+1, -1, rpc_response_func, data);
+ tr_rpc_request_exec_uri (server->session, q + 1, TR_BAD_SIZE, rpc_response_func, data);
}
else
{
const char * str;
tr_variant top;
- tr_rpc_parse_list_str (&top, "12", -1);
+ tr_rpc_parse_list_str (&top, "12", TR_BAD_SIZE);
check (tr_variantIsInt (&top));
check (tr_variantGetInt (&top, &i));
check_int_eq (12, i);
check_int_eq (1, i);
tr_variantFree (&top);
- tr_rpc_parse_list_str (&top, "6,7", -1);
+ tr_rpc_parse_list_str (&top, "6,7", TR_BAD_SIZE);
check (tr_variantIsList (&top));
check (tr_variantListSize (&top) == 2);
check (tr_variantGetInt (tr_variantListChild (&top, 0), &i));
check_int_eq (7, i);
tr_variantFree (&top);
- tr_rpc_parse_list_str (&top, "asdf", -1);
+ tr_rpc_parse_list_str (&top, "asdf", TR_BAD_SIZE);
check (tr_variantIsString (&top));
check (tr_variantGetStr (&top, &str, &len));
check_int_eq (4, len);
check_streq ("asdf", str);
tr_variantFree (&top);
- tr_rpc_parse_list_str (&top, "1,3-5", -1);
+ tr_rpc_parse_list_str (&top, "1,3-5", TR_BAD_SIZE);
check (tr_variantIsList (&top));
check (tr_variantListSize (&top) == 4);
check (tr_variantGetInt (tr_variantListChild (&top, 0), &i));
void
tr_rpc_parse_list_str (tr_variant * setme,
const char * str,
- int len)
+ size_t len)
{
int valueCount;
void
tr_rpc_request_exec_uri (tr_session * session,
const void * request_uri,
- int request_len,
+ size_t request_uri_len,
tr_rpc_response_func callback,
void * callback_user_data)
{
const char * pch;
tr_variant top;
tr_variant * args;
- char * request = tr_strndup (request_uri, request_len);
+ char * request = tr_strndup (request_uri, request_uri_len);
tr_variantInitDict (&top, 3);
args = tr_variantDictAddDict (&top, TR_KEY_arguments, 0);
const char * next = strchr (pch, '&');
if (delim)
{
- char * key = tr_strndup (pch, delim - pch);
+ char * key = tr_strndup (pch, (size_t) (delim - pch));
int isArg = strcmp (key, "method") && strcmp (key, "tag");
tr_variant * parent = isArg ? args : ⊤
- tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, delim-pch)),
+ tr_rpc_parse_list_str (tr_variantDictAdd (parent, tr_quark_new (key, (size_t) (delim - pch))),
delim + 1,
next ? (size_t)(next - (delim + 1)) : strlen (delim + 1));
tr_free (key);
/* see the RPC spec's "Request URI Notation" section */
void tr_rpc_request_exec_uri (tr_session * session,
const void * request_uri,
- int request_len,
+ size_t request_uri_len,
tr_rpc_response_func callback,
void * callback_user_data);
void tr_rpc_parse_list_str (tr_variant * setme,
const char * list_str,
- int list_str_len);
+ size_t list_str_len);
#ifdef __cplusplus
}
#define SHA_DIGEST_LENGTH 20
#define TR_INET6_ADDRSTRLEN 46
+
+#define TR_BAD_SIZE ((size_t) -1)
typedef uint32_t tr_file_index_t;
typedef uint32_t tr_piece_index_t;
char * out;
in = "hello world";
- out = tr_utf8clean (in, -1);
+ out = tr_utf8clean (in, TR_BAD_SIZE);
check_streq (in, out);
tr_free (out);
out = tr_utf8clean (in, 17);
check (out != NULL);
check ((strlen (out) == 17) || (strlen (out) == 33));
- check (tr_utf8_validate (out, -1, NULL));
+ check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
tr_free (out);
/* same string, but utf-8 clean */
in = "Трудно быть Богом";
- out = tr_utf8clean (in, -1);
+ out = tr_utf8clean (in, TR_BAD_SIZE);
check (out != NULL);
- check (tr_utf8_validate (out, -1, NULL));
+ check (tr_utf8_validate (out, TR_BAD_SIZE, NULL));
check_streq (in, out);
tr_free (out);
int count;
int * numbers;
- numbers = tr_parseNumberRange ("1-10,13,16-19", -1, &count);
+ numbers = tr_parseNumberRange ("1-10,13,16-19", TR_BAD_SIZE, &count);
check_int_eq (15, count);
check_int_eq (1, numbers[0]);
check_int_eq (6, numbers[5]);
check_int_eq (19, numbers[14]);
tr_free (numbers);
- numbers = tr_parseNumberRange ("1-5,3-7,2-6", -1, &count);
+ numbers = tr_parseNumberRange ("1-5,3-7,2-6", TR_BAD_SIZE, &count);
check (count == 7);
check (numbers != NULL);
for (i=0; i<count; ++i)
check_int_eq (i+1, numbers[i]);
tr_free (numbers);
- numbers = tr_parseNumberRange ("1-Hello", -1, &count);
+ numbers = tr_parseNumberRange ("1-Hello", TR_BAD_SIZE, &count);
check_int_eq (0, count);
check (numbers == NULL);
- numbers = tr_parseNumberRange ("1-", -1, &count);
+ numbers = tr_parseNumberRange ("1-", TR_BAD_SIZE, &count);
check_int_eq (0, count);
check (numbers == NULL);
- numbers = tr_parseNumberRange ("Hello", -1, &count);
+ numbers = tr_parseNumberRange ("Hello", TR_BAD_SIZE, &count);
check_int_eq (0, count);
check (numbers == NULL);
const char * url;
url = "http://1";
- check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
+ check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
check_streq ("http", scheme);
check_streq ("1", host);
check_streq ("/", path);
tr_free (host);
url = "http://www.some-tracker.org/some/path";
- check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
+ check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
check_streq ("http", scheme);
check_streq ("www.some-tracker.org", host);
check_streq ("/some/path", path);
tr_free (host);
url = "http://www.some-tracker.org:80/some/path";
- check (!tr_urlParse (url, -1, &scheme, &host, &port, &path));
+ check (!tr_urlParse (url, TR_BAD_SIZE, &scheme, &host, &port, &path));
check_streq ("http", scheme);
check_streq ("www.some-tracker.org", host);
check_streq ("/some/path", path);
char*
tr_strdup (const void * in)
{
- return tr_strndup (in, in ? (int)strlen ((const char *)in) : 0);
+ return tr_strndup (in, in != NULL ? strlen (in) : 0);
}
char*
-tr_strndup (const void * in, int len)
+tr_strndup (const void * in, size_t len)
{
char * out = NULL;
- if (len < 0)
+ if (len == TR_BAD_SIZE)
{
out = tr_strdup (in);
}
***/
static bool
-isValidURLChars (const char * url, int url_len)
+isValidURLChars (const char * url, size_t url_len)
{
const char * c;
const char * end;
}
else
{
- const int len = strlen (url);
+ const size_t len = strlen (url);
valid = isValidURLChars (url, len)
&& !tr_urlParse (url, len, NULL, NULL, NULL, NULL)
/** @brief return true if the URL is a http or https or ftp or sftp one that Transmission understands */
bool
-tr_urlIsValid (const char * url, int url_len)
+tr_urlIsValid (const char * url, size_t url_len)
{
bool valid;
}
else
{
- if (url_len < 0)
+ if (url_len == TR_BAD_SIZE)
url_len = strlen (url);
valid = isValidURLChars (url, url_len)
int
tr_urlParse (const char * url_in,
- int len,
+ size_t len,
char ** setme_protocol,
char ** setme_host,
int * setme_port,
{
int err;
int port = 0;
- int n;
+ size_t n;
char * tmp;
char * pch;
size_t host_len;
{
*pch = '\0';
protocol = tmp;
- protocol_len = pch - protocol;
+ protocol_len = (size_t) (pch - protocol);
pch += 3;
if ((n = strcspn (pch, ":/")))
{
}
char*
-tr_utf8clean (const char * str, int max_len)
+tr_utf8clean (const char * str, size_t max_len)
{
char * ret;
const char * end;
- if (max_len < 0)
- max_len = (int) strlen (str);
+ if (max_len == TR_BAD_SIZE)
+ max_len = strlen (str);
if (tr_utf8_validate (str, max_len, &end))
ret = tr_strndup (str, max_len);
else
ret = to_utf8 (str, max_len);
- assert (tr_utf8_validate (ret, -1, NULL));
+ assert (tr_utf8_validate (ret, TR_BAD_SIZE, NULL));
return ret;
}
* Anything else is an error and will return failure.
*/
static bool
-parseNumberSection (const char * str, int len, struct number_range * setme)
+parseNumberSection (const char * str, size_t len, struct number_range * setme)
{
long a, b;
bool success;
* If a fragment of the string can't be parsed, NULL is returned.
*/
int*
-tr_parseNumberRange (const char * str_in, int len, int * setmeCount)
+tr_parseNumberRange (const char * str_in, size_t len, int * setmeCount)
{
int n = 0;
int * uniq = NULL;
const char * pch = strchr (walk, ',');
if (pch)
{
- success = parseNumberSection (walk, pch-walk, &range);
+ success = parseNumberSection (walk, (size_t) (pch - walk), &range);
walk = pch + 1;
}
else
* @param str the string to make a clean copy of
* @param len the length of the string to copy. If -1, the entire string is used.
*/
-char* tr_utf8clean (const char * str, int len) TR_GNUC_MALLOC;
+char* tr_utf8clean (const char * str, size_t len) TR_GNUC_MALLOC;
#ifdef _WIN32
* @param len length of the substring to copy. if a length less than zero is passed in, strlen (len) is used
* @return a newly-allocated copy of `in' that can be freed with tr_free ()
*/
-char* tr_strndup (const void * in, int len) TR_GNUC_MALLOC;
+char* tr_strndup (const void * in, size_t len) TR_GNUC_MALLOC;
/**
* @brief make a newly-allocated copy of a string
bool tr_urlIsValidTracker (const char * url) TR_GNUC_NONNULL (1);
/** @brief return true if the url is a [ http, https, ftp, ftps ] url that Transmission understands */
-bool tr_urlIsValid (const char * url, int url_len) TR_GNUC_NONNULL (1);
+bool tr_urlIsValid (const char * url, size_t url_len) TR_GNUC_NONNULL (1);
/** @brief parse a URL into its component parts
@return zero on success or an error number if an error occurred */
int tr_urlParse (const char * url,
- int url_len,
+ size_t url_len,
char ** setme_scheme,
char ** setme_host,
int * setme_port,
* For example, "5-8" will return [ 5, 6, 7, 8 ] and setmeCount will be 4.
*/
int* tr_parseNumberRange (const char * str,
- int str_len,
- int * setmeCount) TR_GNUC_MALLOC TR_GNUC_NONNULL (1);
+ size_t str_len,
+ int * setmeCount) TR_GNUC_MALLOC TR_GNUC_NONNULL (1);
/**
static void
tr_variant_string_set_string (struct tr_variant_string * str,
const char * bytes,
- int len)
+ size_t len)
{
tr_variant_string_clear (str);
if (bytes == NULL)
len = 0;
- else if (len < 0)
+ else if (len == TR_BAD_SIZE)
len = strlen (bytes);
- if ((size_t)len < sizeof(str->str.buf))
+ if (len < sizeof (str->str.buf))
{
str->type = TR_STRING_TYPE_BUF;
memcpy (str->str.buf, bytes, len);
}
void
-tr_variantInitStr (tr_variant * v, const void * str, int len)
+tr_variantInitStr (tr_variant * v, const void * str, size_t len)
{
tr_variantInit (v, TR_VARIANT_TYPE_STR);
tr_variant_string_set_string (&v->val.s, str, len);
const char * val)
{
tr_variant * child = tr_variantListAdd (list);
- tr_variantInitStr (child, val, -1);
+ tr_variantInitStr (child, val, TR_BAD_SIZE);
return child;
}
const char * val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_STR);
- tr_variantInitStr (child, val, -1);
+ tr_variantInitStr (child, val, TR_BAD_SIZE);
return child;
}
void tr_variantInitStr (tr_variant * initme,
const void * str,
- int str_len);
+ size_t str_len);
void tr_variantInitQuark (tr_variant * initme,
const tr_quark quark);
str += inf.st.isBackup ? QLatin1String ("<i>") : QLatin1String ("<b>");
char * host = NULL;
int port = 0;
- tr_urlParse (inf.st.announce.toUtf8().constData(), -1, NULL, &host, &port, NULL);
+ tr_urlParse (inf.st.announce.toUtf8().constData(), TR_BAD_SIZE, NULL, &host, &port, NULL);
str += QString::fromLatin1 ("%1:%2").arg (QString::fromUtf8 (host)).arg (port);
tr_free (host);
if (!key.isEmpty()) str += QLatin1String (" - ") + key;
char * newstr = replaceSubstr (str, in, out);
printf ("\tReplaced in \"announce-list\" tier %d: \"%s\" --> \"%s\"\n", tierCount, str, newstr);
tr_variantFree (node);
- tr_variantInitStr (node, newstr, -1);
+ tr_variantInitStr (node, newstr, TR_BAD_SIZE);
tr_free (newstr);
changed = true;
}
projects / transmission / commitdiff