@matheusbsbs / matheus-bagliano / commits / 028c297638
Fork 0

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 }