Use strbuf in http code
Also, replace whitespaces with tabs in some places Signed-off-by: Mike Hommey <mh@glandium.org> Signed-off-by: Junio C Hamano <gitster@pobox.com>
Mike Hommey committed
Dec 9, 2007 at 20:30 UTC
028c2976389f70e7349bbfeeef0ed0a000d5e447
5 files changed
+108
-201
http-push.c
+61
-126
@@ -494,10 +494,11 @@ static void start_put(struct transfer_request *request)
494
memset(&stream, 0, sizeof(stream));
495
deflateInit(&stream, zlib_compression_level);
496
size = deflateBound(&stream, len + hdrlen);
497
- request->buffer.buffer = xmalloc(size);
497
+ strbuf_init(&request->buffer.buf, size);
498
+ request->buffer.posn = 0;
499
500
/* Compress it */
500
- stream.next_out = request->buffer.buffer;
501
+ stream.next_out = (unsigned char *)request->buffer.buf.buf;
502
stream.avail_out = size;
503
504
/* First header.. */
@@ -514,8 +515,7 @@ static void start_put(struct transfer_request *request)
515
deflateEnd(&stream);
516
free(unpacked);
517
517
- request->buffer.size = stream.total_out;
518
- request->buffer.posn = 0;
518
+ request->buffer.buf.len = stream.total_out;
519
520
request->url = xmalloc(strlen(remote->url) +
521
strlen(request->lock->token) + 51);
@@ -537,7 +537,7 @@ static void start_put(struct transfer_request *request)
537
slot->callback_func = process_response;
538
slot->callback_data = request;
539
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &request->buffer);
540
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.size);
540
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, request->buffer.buf.len);
541
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
542
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
543
curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
@@ -1007,18 +1007,13 @@ static int fetch_indices(void)
1007
{
1008
unsigned char sha1[20];
1009
char *url;
1010
- struct buffer buffer;
1010
+ struct strbuf buffer = STRBUF_INIT;
1011
char *data;
1012
int i = 0;
1013
1014
struct active_request_slot *slot;
1015
struct slot_results results;
1016
1017
- data = xcalloc(1, 4096);
1018
- buffer.size = 4096;
1019
- buffer.posn = 0;
1020
- buffer.buffer = data;
1021
-
1017
if (push_verbosely)
1018
fprintf(stderr, "Getting pack list\n");
1019
@@ -1034,7 +1029,7 @@ static int fetch_indices(void)
1029
if (start_active_slot(slot)) {
1030
run_active_slot(slot);
1031
if (results.curl_result != CURLE_OK) {
1037
- free(buffer.buffer);
1032
+ strbuf_release(&buffer);
1033
free(url);
1034
if (results.http_code == 404)
1035
return 0;
@@ -1042,18 +1037,18 @@ static int fetch_indices(void)
1037
return error("%s", curl_errorstr);
1038
}
1039
} else {
1045
- free(buffer.buffer);
1040
+ strbuf_release(&buffer);
1041
free(url);
1042
return error("Unable to start request");
1043
}
1044
free(url);
1045
1051
- data = buffer.buffer;
1052
- while (i < buffer.posn) {
1046
+ data = buffer.buf;
1047
+ while (i < buffer.len) {
1048
switch (data[i]) {
1049
case 'P':
1050
i++;
1056
- if (i + 52 < buffer.posn &&
1051
+ if (i + 52 < buffer.len &&
1052
!prefixcmp(data + i, " pack-") &&
1053
!prefixcmp(data + i + 46, ".pack\n")) {
1054
get_sha1_hex(data + i + 6, sha1);
@@ -1068,7 +1063,7 @@ static int fetch_indices(void)
1063
i++;
1064
}
1065
1071
- free(buffer.buffer);
1066
+ strbuf_release(&buffer);
1067
return 0;
1068
}
1069
@@ -1119,16 +1114,11 @@ static char *quote_ref_url(const char *base, const char *ref)
1114
1115
int fetch_ref(char *ref, unsigned char *sha1)
1116
{
1122
- char *url;
1123
- char hex[42];
1124
- struct buffer buffer;
1117
+ char *url;
1118
+ struct strbuf buffer = STRBUF_INIT;
1119
char *base = remote->url;
1120
struct active_request_slot *slot;
1121
struct slot_results results;
1128
- buffer.size = 41;
1129
- buffer.posn = 0;
1130
- buffer.buffer = hex;
1131
- hex[41] = '\0';
1122
1123
url = quote_ref_url(base, ref);
1124
slot = get_active_slot();
@@ -1148,10 +1138,10 @@ int fetch_ref(char *ref, unsigned char *sha1)
1138
return error("Unable to start request");
1139
}
1140
1151
- if (buffer.posn != 41)
1141
+ strbuf_rtrim(&buffer);
1142
+ if (buffer.len != 40)
1143
return 1;
1153
- hex[40] = '\0';
1154
- return get_sha1_hex(hex, sha1);
1144
+ return get_sha1_hex(buffer.buf, sha1);
1145
}
1146
1147
static void one_remote_object(const char *hex)
@@ -1274,10 +1264,8 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
1264
{
1265
struct active_request_slot *slot;
1266
struct slot_results results;
1277
- struct buffer out_buffer;
1278
- struct buffer in_buffer;
1279
- char *out_data;
1280
- char *in_data;
1267
+ struct buffer out_buffer = { STRBUF_INIT, 0 };
1268
+ struct strbuf in_buffer = STRBUF_INIT;
1269
char *url;
1270
char *ep;
1271
char timeout_header[25];
@@ -1317,16 +1305,7 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
1305
ep = strchr(ep + 1, '/');
1306
}
1307
1320
- out_buffer.size = strlen(LOCK_REQUEST) + strlen(git_default_email) - 2;
1321
- out_data = xmalloc(out_buffer.size + 1);
1322
- snprintf(out_data, out_buffer.size + 1, LOCK_REQUEST, git_default_email);
1323
- out_buffer.posn = 0;
1324
- out_buffer.buffer = out_data;
1325
-
1326
- in_buffer.size = 4096;
1327
- in_data = xmalloc(in_buffer.size);
1328
- in_buffer.posn = 0;
1329
- in_buffer.buffer = in_data;
1308
+ strbuf_addf(&out_buffer.buf, LOCK_REQUEST, git_default_email);
1309
1310
sprintf(timeout_header, "Timeout: Second-%ld", timeout);
1311
dav_headers = curl_slist_append(dav_headers, timeout_header);
@@ -1335,7 +1314,7 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
1314
slot = get_active_slot();
1315
slot->results = &results;
1316
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1338
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1317
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.buf.len);
1318
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1319
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1320
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
@@ -1361,8 +1340,8 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
1340
XML_SetElementHandler(parser, xml_start_tag,
1341
xml_end_tag);
1342
XML_SetCharacterDataHandler(parser, xml_cdata);
1364
- result = XML_Parse(parser, in_buffer.buffer,
1365
- in_buffer.posn, 1);
1343
+ result = XML_Parse(parser, in_buffer.buf,
1344
+ in_buffer.len, 1);
1345
free(ctx.name);
1346
if (result != XML_STATUS_OK) {
1347
fprintf(stderr, "XML error: %s\n",
@@ -1377,8 +1356,8 @@ static struct remote_lock *lock_remote(const char *path, long timeout)
1356
}
1357
1358
curl_slist_free_all(dav_headers);
1380
- free(out_data);
1381
- free(in_data);
1359
+ strbuf_release(&out_buffer.buf);
1360
+ strbuf_release(&in_buffer);
1361
1362
if (lock->token == NULL || lock->timeout <= 0) {
1363
if (lock->token != NULL)
@@ -1529,10 +1508,8 @@ static void remote_ls(const char *path, int flags,
1508
char *url = xmalloc(strlen(remote->url) + strlen(path) + 1);
1509
struct active_request_slot *slot;
1510
struct slot_results results;
1532
- struct buffer in_buffer;
1533
- struct buffer out_buffer;
1534
- char *in_data;
1535
- char *out_data;
1511
+ struct strbuf in_buffer = STRBUF_INIT;
1512
+ struct buffer out_buffer = { STRBUF_INIT, 0 };
1513
struct curl_slist *dav_headers = NULL;
1514
struct xml_ctx ctx;
1515
struct remote_ls_ctx ls;
@@ -1546,16 +1523,7 @@ static void remote_ls(const char *path, int flags,
1523
1524
sprintf(url, "%s%s", remote->url, path);
1525
1549
- out_buffer.size = strlen(PROPFIND_ALL_REQUEST);
1550
- out_data = xmalloc(out_buffer.size + 1);
1551
- snprintf(out_data, out_buffer.size + 1, PROPFIND_ALL_REQUEST);
1552
- out_buffer.posn = 0;
1553
- out_buffer.buffer = out_data;
1554
-
1555
- in_buffer.size = 4096;
1556
- in_data = xmalloc(in_buffer.size);
1557
- in_buffer.posn = 0;
1558
- in_buffer.buffer = in_data;
1526
+ strbuf_addf(&out_buffer.buf, PROPFIND_ALL_REQUEST);
1527
1528
dav_headers = curl_slist_append(dav_headers, "Depth: 1");
1529
dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
@@ -1563,7 +1531,7 @@ static void remote_ls(const char *path, int flags,
1531
slot = get_active_slot();
1532
slot->results = &results;
1533
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1566
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1534
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.buf.len);
1535
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1536
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1537
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
@@ -1586,8 +1554,8 @@ static void remote_ls(const char *path, int flags,
1554
XML_SetElementHandler(parser, xml_start_tag,
1555
xml_end_tag);
1556
XML_SetCharacterDataHandler(parser, xml_cdata);
1589
- result = XML_Parse(parser, in_buffer.buffer,
1590
- in_buffer.posn, 1);
1557
+ result = XML_Parse(parser, in_buffer.buf,
1558
+ in_buffer.len, 1);
1559
free(ctx.name);
1560
1561
if (result != XML_STATUS_OK) {
@@ -1603,8 +1571,8 @@ static void remote_ls(const char *path, int flags,
1571
1572
free(ls.path);
1573
free(url);
1606
- free(out_data);
1607
- free(in_buffer.buffer);
1574
+ strbuf_release(&out_buffer.buf);
1575
+ strbuf_release(&in_buffer);
1576
curl_slist_free_all(dav_headers);
1577
}
1578
@@ -1625,27 +1593,13 @@ static int locking_available(void)
1593
{
1594
struct active_request_slot *slot;
1595
struct slot_results results;
1628
- struct buffer in_buffer;
1629
- struct buffer out_buffer;
1630
- char *in_data;
1631
- char *out_data;
1596
+ struct strbuf in_buffer = STRBUF_INIT;
1597
+ struct buffer out_buffer = { STRBUF_INIT, 0 };
1598
struct curl_slist *dav_headers = NULL;
1599
struct xml_ctx ctx;
1600
int lock_flags = 0;
1601
1636
- out_buffer.size =
1637
- strlen(PROPFIND_SUPPORTEDLOCK_REQUEST) +
1638
- strlen(remote->url) - 2;
1639
- out_data = xmalloc(out_buffer.size + 1);
1640
- snprintf(out_data, out_buffer.size + 1,
1641
- PROPFIND_SUPPORTEDLOCK_REQUEST, remote->url);
1642
- out_buffer.posn = 0;
1643
- out_buffer.buffer = out_data;
1644
-
1645
- in_buffer.size = 4096;
1646
- in_data = xmalloc(in_buffer.size);
1647
- in_buffer.posn = 0;
1648
- in_buffer.buffer = in_data;
1602
+ strbuf_addf(&out_buffer.buf, PROPFIND_SUPPORTEDLOCK_REQUEST, remote->url);
1603
1604
dav_headers = curl_slist_append(dav_headers, "Depth: 0");
1605
dav_headers = curl_slist_append(dav_headers, "Content-Type: text/xml");
@@ -1653,7 +1607,7 @@ static int locking_available(void)
1607
slot = get_active_slot();
1608
slot->results = &results;
1609
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1656
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1610
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.buf.len);
1611
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1612
curl_easy_setopt(slot->curl, CURLOPT_FILE, &in_buffer);
1613
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_buffer);
@@ -1675,8 +1629,8 @@ static int locking_available(void)
1629
XML_SetUserData(parser, &ctx);
1630
XML_SetElementHandler(parser, xml_start_tag,
1631
xml_end_tag);
1678
- result = XML_Parse(parser, in_buffer.buffer,
1679
- in_buffer.posn, 1);
1632
+ result = XML_Parse(parser, in_buffer.buf,
1633
+ in_buffer.len, 1);
1634
free(ctx.name);
1635
1636
if (result != XML_STATUS_OK) {
@@ -1691,8 +1645,8 @@ static int locking_available(void)
1645
fprintf(stderr, "Unable to start PROPFIND request\n");
1646
}
1647
1694
- free(out_data);
1695
- free(in_buffer.buffer);
1648
+ strbuf_release(&out_buffer.buf);
1649
+ strbuf_release(&in_buffer);
1650
curl_slist_free_all(dav_headers);
1651
1652
return lock_flags;
@@ -1810,30 +1764,20 @@ static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1764
{
1765
struct active_request_slot *slot;
1766
struct slot_results results;
1813
- char *out_data;
1767
char *if_header;
1815
- struct buffer out_buffer;
1768
+ struct buffer out_buffer = { STRBUF_INIT, 0 };
1769
struct curl_slist *dav_headers = NULL;
1817
- int i;
1770
1771
if_header = xmalloc(strlen(lock->token) + 25);
1772
sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
1773
dav_headers = curl_slist_append(dav_headers, if_header);
1774
1823
- out_buffer.size = 41;
1824
- out_data = xmalloc(out_buffer.size + 1);
1825
- i = snprintf(out_data, out_buffer.size + 1, "%s\n", sha1_to_hex(sha1));
1826
- if (i != out_buffer.size) {
1827
- fprintf(stderr, "Unable to initialize PUT request body\n");
1828
- return 0;
1829
- }
1830
- out_buffer.posn = 0;
1831
- out_buffer.buffer = out_data;
1775
+ strbuf_addf(&out_buffer.buf, "%s\n", sha1_to_hex(sha1));
1776
1777
slot = get_active_slot();
1778
slot->results = &results;
1779
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &out_buffer);
1836
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.size);
1780
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, out_buffer.buf.len);
1781
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
1782
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
1783
curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
@@ -1844,7 +1788,7 @@ static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1788
1789
if (start_active_slot(slot)) {
1790
run_active_slot(slot);
1847
- free(out_data);
1791
+ strbuf_release(&out_buffer.buf);
1792
free(if_header);
1793
if (results.curl_result != CURLE_OK) {
1794
fprintf(stderr,
@@ -1854,7 +1798,7 @@ static int update_remote(unsigned char *sha1, struct remote_lock *lock)
1798
return 0;
1799
}
1800
} else {
1857
- free(out_data);
1801
+ strbuf_release(&out_buffer.buf);
1802
free(if_header);
1803
fprintf(stderr, "Unable to start PUT request\n");
1804
return 0;
@@ -2011,7 +1955,7 @@ static void mark_edges_uninteresting(struct commit_list *list)
1955
1956
static void add_remote_info_ref(struct remote_ls_ctx *ls)
1957
{
2014
- struct buffer *buf = (struct buffer *)ls->userData;
1958
+ struct strbuf *buf = (struct strbuf *)ls->userData;
1959
unsigned char remote_sha1[20];
1960
struct object *o;
1961
int len;
@@ -2056,17 +2000,14 @@ static void add_remote_info_ref(struct remote_ls_ctx *ls)
2000
2001
static void update_remote_info_refs(struct remote_lock *lock)
2002
{
2059
- struct buffer buffer;
2003
+ struct buffer buffer = { STRBUF_INIT, 0 };
2004
struct active_request_slot *slot;
2005
struct slot_results results;
2006
char *if_header;
2007
struct curl_slist *dav_headers = NULL;
2008
2065
- buffer.buffer = xcalloc(1, 4096);
2066
- buffer.size = 4096;
2067
- buffer.posn = 0;
2009
remote_ls("refs/", (PROCESS_FILES | RECURSIVE),
2069
- add_remote_info_ref, &buffer);
2010
+ add_remote_info_ref, &buffer.buf);
2011
if (!aborted) {
2012
if_header = xmalloc(strlen(lock->token) + 25);
2013
sprintf(if_header, "If: (<opaquelocktoken:%s>)", lock->token);
@@ -2075,7 +2016,7 @@ static void update_remote_info_refs(struct remote_lock *lock)
2016
slot = get_active_slot();
2017
slot->results = &results;
2018
curl_easy_setopt(slot->curl, CURLOPT_INFILE, &buffer);
2078
- curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, buffer.posn);
2019
+ curl_easy_setopt(slot->curl, CURLOPT_INFILESIZE, buffer.buf.len);
2020
curl_easy_setopt(slot->curl, CURLOPT_READFUNCTION, fread_buffer);
2021
curl_easy_setopt(slot->curl, CURLOPT_WRITEFUNCTION, fwrite_null);
2022
curl_easy_setopt(slot->curl, CURLOPT_CUSTOMREQUEST, DAV_PUT);
@@ -2084,8 +2025,6 @@ static void update_remote_info_refs(struct remote_lock *lock)
2025
curl_easy_setopt(slot->curl, CURLOPT_PUT, 1);
2026
curl_easy_setopt(slot->curl, CURLOPT_URL, lock->url);
2027
2087
- buffer.posn = 0;
2088
-
2028
if (start_active_slot(slot)) {
2029
run_active_slot(slot);
2030
if (results.curl_result != CURLE_OK) {
@@ -2096,7 +2035,7 @@ static void update_remote_info_refs(struct remote_lock *lock)
2035
}
2036
free(if_header);
2037
}
2099
- free(buffer.buffer);
2038
+ strbuf_release(&buffer.buf);
2039
}
2040
2041
static int remote_exists(const char *path)
@@ -2107,12 +2046,12 @@ static int remote_exists(const char *path)
2046
2047
sprintf(url, "%s%s", remote->url, path);
2048
2110
- slot = get_active_slot();
2049
+ slot = get_active_slot();
2050
slot->results = &results;
2112
- curl_easy_setopt(slot->curl, CURLOPT_URL, url);
2113
- curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
2051
+ curl_easy_setopt(slot->curl, CURLOPT_URL, url);
2052
+ curl_easy_setopt(slot->curl, CURLOPT_NOBODY, 1);
2053
2115
- if (start_active_slot(slot)) {
2054
+ if (start_active_slot(slot)) {
2055
run_active_slot(slot);
2056
free(url);
2057
if (results.http_code == 404)
@@ -2132,17 +2071,13 @@ static int remote_exists(const char *path)
2071
static void fetch_symref(const char *path, char **symref, unsigned char *sha1)
2072
{
2073
char *url;
2135
- struct buffer buffer;
2074
+ struct strbuf buffer = STRBUF_INIT;
2075
struct active_request_slot *slot;
2076
struct slot_results results;
2077
2078
url = xmalloc(strlen(remote->url) + strlen(path) + 1);
2079
sprintf(url, "%s%s", remote->url, path);
2080
2142
- buffer.size = 4096;
2143
- buffer.posn = 0;
2144
- buffer.buffer = xmalloc(buffer.size);
2145
-
2081
slot = get_active_slot();
2082
slot->results = &results;
2083
curl_easy_setopt(slot->curl, CURLOPT_FILE, &buffer);
@@ -2165,17 +2100,17 @@ static void fetch_symref(const char *path, char **symref, unsigned char *sha1)
2100
*symref = NULL;
2101
hashclr(sha1);
2102
2168
- if (buffer.posn == 0)
2103
+ if (buffer.len == 0)
2104
return;
2105
2106
/* If it's a symref, set the refname; otherwise try for a sha1 */
2172
- if (!prefixcmp((char *)buffer.buffer, "ref: ")) {
2173
- *symref = xmemdupz((char *)buffer.buffer + 5, buffer.posn - 6);
2107
+ if (!prefixcmp((char *)buffer.buf, "ref: ")) {
2108
+ *symref = xmemdupz((char *)buffer.buf + 5, buffer.len - 6);
2109
} else {
2175
- get_sha1_hex(buffer.buffer, sha1);
2110
+ get_sha1_hex(buffer.buf, sha1);
2111
}
2112
2178
- free(buffer.buffer);
2113
+ strbuf_release(&buffer);
2114
}
2115
2116
static int verify_merge_base(unsigned char *head_sha1, unsigned char *branch_sha1)
http-walker.c
+21
-38
@@ -48,7 +48,7 @@ struct alternates_request {
48
struct walker *walker;
49
const char *base;
50
char *url;
51
- struct buffer *buffer;
51
+ struct strbuf *buffer;
52
struct active_request_slot *slot;
53
int http_specific;
54
};
@@ -462,7 +462,7 @@ static void process_alternates_response(void *callback_data)
462
463
if (alt_req->http_specific) {
464
if (slot->curl_result != CURLE_OK ||
465
- !alt_req->buffer->posn) {
465
+ !alt_req->buffer->len) {
466
467
/* Try reusing the slot to get non-http alternates */
468
alt_req->http_specific = 0;
@@ -490,12 +490,12 @@ static void process_alternates_response(void *callback_data)
490
}
491
492
fwrite_buffer(&null_byte, 1, 1, alt_req->buffer);
493
- alt_req->buffer->posn--;
494
- data = alt_req->buffer->buffer;
493
+ alt_req->buffer->len--;
494
+ data = alt_req->buffer->buf;
495
496
- while (i < alt_req->buffer->posn) {
496
+ while (i < alt_req->buffer->len) {
497
int posn = i;
498
- while (posn < alt_req->buffer->posn && data[posn] != '\n')
498
+ while (posn < alt_req->buffer->len && data[posn] != '\n')
499
posn++;
500
if (data[posn] == '\n') {
501
int okay = 0;
@@ -583,9 +583,8 @@ static void process_alternates_response(void *callback_data)
583
584
static void fetch_alternates(struct walker *walker, const char *base)
585
{
586
- struct buffer buffer;
586
+ struct strbuf buffer = STRBUF_INIT;
587
char *url;
588
- char *data;
588
struct active_request_slot *slot;
589
struct alternates_request alt_req;
590
struct walker_data *cdata = walker->data;
@@ -606,11 +605,6 @@ static void fetch_alternates(struct walker *walker, const char *base)
605
/* Start the fetch */
606
cdata->got_alternates = 0;
607
609
- data = xmalloc(4096);
610
- buffer.size = 4096;
611
- buffer.posn = 0;
612
- buffer.buffer = data;
613
-
608
if (walker->get_verbosely)
609
fprintf(stderr, "Getting alternates list for %s\n", base);
610
@@ -639,7 +633,7 @@ static void fetch_alternates(struct walker *walker, const char *base)
633
else
634
cdata->got_alternates = -1;
635
642
- free(data);
636
+ strbuf_release(&buffer);
637
free(url);
638
}
639
@@ -647,7 +641,7 @@ static int fetch_indices(struct walker *walker, struct alt_base *repo)
641
{
642
unsigned char sha1[20];
643
char *url;
650
- struct buffer buffer;
644
+ struct strbuf buffer = STRBUF_INIT;
645
char *data;
646
int i = 0;
647
@@ -657,11 +651,6 @@ static int fetch_indices(struct walker *walker, struct alt_base *repo)
651
if (repo->got_indices)
652
return 0;
653
660
- data = xmalloc(4096);
661
- buffer.size = 4096;
662
- buffer.posn = 0;
663
- buffer.buffer = data;
664
-
654
if (walker->get_verbosely)
655
fprintf(stderr, "Getting pack list for %s\n", repo->base);
656
@@ -677,28 +666,27 @@ static int fetch_indices(struct walker *walker, struct alt_base *repo)
666
if (start_active_slot(slot)) {
667
run_active_slot(slot);
668
if (results.curl_result != CURLE_OK) {
669
+ strbuf_release(&buffer);
670
if (missing_target(&results)) {
671
repo->got_indices = 1;
682
- free(buffer.buffer);
672
return 0;
673
} else {
674
repo->got_indices = 0;
686
- free(buffer.buffer);
675
return error("%s", curl_errorstr);
676
}
677
}
678
} else {
679
repo->got_indices = 0;
692
- free(buffer.buffer);
680
+ strbuf_release(&buffer);
681
return error("Unable to start request");
682
}
683
696
- data = buffer.buffer;
697
- while (i < buffer.posn) {
684
+ data = buffer.buf;
685
+ while (i < buffer.len) {
686
switch (data[i]) {
687
case 'P':
688
i++;
701
- if (i + 52 <= buffer.posn &&
689
+ if (i + 52 <= buffer.len &&
690
!prefixcmp(data + i, " pack-") &&
691
!prefixcmp(data + i + 46, ".pack\n")) {
692
get_sha1_hex(data + i + 6, sha1);
@@ -707,13 +695,13 @@ static int fetch_indices(struct walker *walker, struct alt_base *repo)
695
break;
696
}
697
default:
710
- while (i < buffer.posn && data[i] != '\n')
698
+ while (i < buffer.len && data[i] != '\n')
699
i++;
700
}
701
i++;
702
}
703
716
- free(buffer.buffer);
704
+ strbuf_release(&buffer);
705
repo->got_indices = 1;
706
return 0;
707
}
@@ -945,17 +933,12 @@ static char *quote_ref_url(const char *base, const char *ref)
933
934
static int fetch_ref(struct walker *walker, char *ref, unsigned char *sha1)
935
{
948
- char *url;
949
- char hex[42];
950
- struct buffer buffer;
936
+ char *url;
937
+ struct strbuf buffer = STRBUF_INIT;
938
struct walker_data *data = walker->data;
939
const char *base = data->alt->base;
940
struct active_request_slot *slot;
941
struct slot_results results;
955
- buffer.size = 41;
956
- buffer.posn = 0;
957
- buffer.buffer = hex;
958
- hex[41] = '\0';
942
943
url = quote_ref_url(base, ref);
944
slot = get_active_slot();
@@ -973,10 +956,10 @@ static int fetch_ref(struct walker *walker, char *ref, unsigned char *sha1)
956
return error("Unable to start request");
957
}
958
976
- if (buffer.posn != 41)
959
+ strbuf_rtrim(&buffer);
960
+ if (buffer.len != 40)
961
return 1;
978
- hex[40] = '\0';
979
- return get_sha1_hex(hex, sha1);
962
+ return get_sha1_hex(buffer.buf, sha1);
963
}
964
965
static void cleanup(struct walker *walker)
http.c
+14
-20
@@ -34,31 +34,25 @@ size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
34
struct buffer *buffer)
35
{
36
size_t size = eltsize * nmemb;
37
- if (size > buffer->size - buffer->posn)
38
- size = buffer->size - buffer->posn;
39
- memcpy(ptr, (char *) buffer->buffer + buffer->posn, size);
37
+ if (size > buffer->buf.len - buffer->posn)
38
+ size = buffer->buf.len - buffer->posn;
39
+ memcpy(ptr, buffer->buf.buf + buffer->posn, size);
40
buffer->posn += size;
41
+
42
return size;
43
}
44
45
size_t fwrite_buffer(const void *ptr, size_t eltsize,
45
- size_t nmemb, struct buffer *buffer)
46
+ size_t nmemb, struct strbuf *buffer)
47
{
48
size_t size = eltsize * nmemb;
48
- if (size > buffer->size - buffer->posn) {
49
- buffer->size = buffer->size * 3 / 2;
50
- if (buffer->size < buffer->posn + size)
51
- buffer->size = buffer->posn + size;
52
- buffer->buffer = xrealloc(buffer->buffer, buffer->size);
53
- }
54
- memcpy((char *) buffer->buffer + buffer->posn, ptr, size);
55
- buffer->posn += size;
49
+ strbuf_add(buffer, ptr, size);
50
data_received++;
51
return size;
52
}
53
54
size_t fwrite_null(const void *ptr, size_t eltsize,
61
- size_t nmemb, struct buffer *buffer)
55
+ size_t nmemb, struct strbuf *buffer)
56
{
57
data_received++;
58
return eltsize * nmemb;
@@ -507,8 +501,8 @@ void run_active_slot(struct active_request_slot *slot)
501
502
static void closedown_active_slot(struct active_request_slot *slot)
503
{
510
- active_requests--;
511
- slot->in_use = 0;
504
+ active_requests--;
505
+ slot->in_use = 0;
506
}
507
508
void release_active_slot(struct active_request_slot *slot)
@@ -529,7 +523,7 @@ void release_active_slot(struct active_request_slot *slot)
523
static void finish_active_slot(struct active_request_slot *slot)
524
{
525
closedown_active_slot(slot);
532
- curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);
526
+ curl_easy_getinfo(slot->curl, CURLINFO_HTTP_CODE, &slot->http_code);
527
528
if (slot->finished != NULL)
529
(*slot->finished) = 1;
@@ -540,10 +534,10 @@ static void finish_active_slot(struct active_request_slot *slot)
534
slot->results->http_code = slot->http_code;
535
}
536
543
- /* Run callback if appropriate */
544
- if (slot->callback_func != NULL) {
545
- slot->callback_func(slot->callback_data);
546
- }
537
+ /* Run callback if appropriate */
538
+ if (slot->callback_func != NULL) {
539
+ slot->callback_func(slot->callback_data);
540
+ }
541
}
542
543
void finish_all_active_slots(void)
http.h
+6
-5
@@ -6,6 +6,8 @@
6
#include <curl/curl.h>
7
#include <curl/easy.h>
8
9
+#include "strbuf.h"
10
+
11
#if LIBCURL_VERSION_NUM >= 0x071000
12
#define USE_CURL_MULTI
13
#define DEFAULT_MAX_REQUESTS 5
@@ -48,18 +50,17 @@ struct active_request_slot
50
51
struct buffer
52
{
51
- size_t posn;
52
- size_t size;
53
- void *buffer;
53
+ struct strbuf buf;
54
+ size_t posn;
55
};
56
57
/* Curl request read/write callbacks */
58
extern size_t fread_buffer(void *ptr, size_t eltsize, size_t nmemb,
59
struct buffer *buffer);
60
extern size_t fwrite_buffer(const void *ptr, size_t eltsize,
60
- size_t nmemb, struct buffer *buffer);
61
+ size_t nmemb, struct strbuf *buffer);
62
extern size_t fwrite_null(const void *ptr, size_t eltsize,
62
- size_t nmemb, struct buffer *buffer);
63
+ size_t nmemb, struct strbuf *buffer);
64
65
/* Slot lifecycle functions */
66
extern struct active_request_slot *get_active_slot(void);
transport.c
+6
-12
@@ -428,7 +428,7 @@ static int curl_transport_push(struct transport *transport, int refspec_nr, cons
428
429
static struct ref *get_refs_via_curl(struct transport *transport)
430
{
431
- struct buffer buffer;
431
+ struct strbuf buffer = STRBUF_INIT;
432
char *data, *start, *mid;
433
char *ref_name;
434
char *refs_url;
@@ -441,11 +441,6 @@ static struct ref *get_refs_via_curl(struct transport *transport)
441
struct ref *ref = NULL;
442
struct ref *last_ref = NULL;
443
444
- data = xmalloc(4096);
445
- buffer.size = 4096;
446
- buffer.posn = 0;
447
- buffer.buffer = data;
448
-
444
refs_url = xmalloc(strlen(transport->url) + 11);
445
sprintf(refs_url, "%s/info/refs", transport->url);
446
@@ -464,27 +459,26 @@ static struct ref *get_refs_via_curl(struct transport *transport)
459
if (start_active_slot(slot)) {
460
run_active_slot(slot);
461
if (results.curl_result != CURLE_OK) {
462
+ strbuf_release(&buffer);
463
if (missing_target(&results)) {
468
- free(buffer.buffer);
464
return NULL;
465
} else {
471
- free(buffer.buffer);
466
error("%s", curl_errorstr);
467
return NULL;
468
}
469
}
470
} else {
477
- free(buffer.buffer);
471
+ strbuf_release(&buffer);
472
error("Unable to start request");
473
return NULL;
474
}
475
476
http_cleanup();
477
484
- data = buffer.buffer;
478
+ data = buffer.buf;
479
start = NULL;
480
mid = data;
487
- while (i < buffer.posn) {
481
+ while (i < buffer.len) {
482
if (!start)
483
start = &data[i];
484
if (data[i] == '\t')
@@ -507,7 +501,7 @@ static struct ref *get_refs_via_curl(struct transport *transport)
501
i++;
502
}
503
510
- free(buffer.buffer);
504
+ strbuf_release(&buffer);
505
506
return refs;
507
}