strbuf.c 3.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include "debug.h"
  3. #include "util.h"
  4. #include <linux/kernel.h>
  5. #include <errno.h>
  6. /*
  7. * Used as the default ->buf value, so that people can always assume
  8. * buf is non NULL and ->buf is NUL terminated even for a freshly
  9. * initialized strbuf.
  10. */
  11. char strbuf_slopbuf[1];
  12. int strbuf_init(struct strbuf *sb, ssize_t hint)
  13. {
  14. sb->alloc = sb->len = 0;
  15. sb->buf = strbuf_slopbuf;
  16. if (hint)
  17. return strbuf_grow(sb, hint);
  18. return 0;
  19. }
  20. void strbuf_release(struct strbuf *sb)
  21. {
  22. if (sb->alloc) {
  23. zfree(&sb->buf);
  24. strbuf_init(sb, 0);
  25. }
  26. }
  27. char *strbuf_detach(struct strbuf *sb, size_t *sz)
  28. {
  29. char *res = sb->alloc ? sb->buf : NULL;
  30. if (sz)
  31. *sz = sb->len;
  32. strbuf_init(sb, 0);
  33. return res;
  34. }
  35. int strbuf_grow(struct strbuf *sb, size_t extra)
  36. {
  37. char *buf;
  38. size_t nr = sb->len + extra + 1;
  39. if (nr < sb->alloc)
  40. return 0;
  41. if (nr <= sb->len)
  42. return -E2BIG;
  43. if (alloc_nr(sb->alloc) > nr)
  44. nr = alloc_nr(sb->alloc);
  45. /*
  46. * Note that sb->buf == strbuf_slopbuf if sb->alloc == 0, and it is
  47. * a static variable. Thus we have to avoid passing it to realloc.
  48. */
  49. buf = realloc(sb->alloc ? sb->buf : NULL, nr * sizeof(*buf));
  50. if (!buf)
  51. return -ENOMEM;
  52. sb->buf = buf;
  53. sb->alloc = nr;
  54. return 0;
  55. }
  56. int strbuf_addch(struct strbuf *sb, int c)
  57. {
  58. int ret = strbuf_grow(sb, 1);
  59. if (ret)
  60. return ret;
  61. sb->buf[sb->len++] = c;
  62. sb->buf[sb->len] = '\0';
  63. return 0;
  64. }
  65. int strbuf_add(struct strbuf *sb, const void *data, size_t len)
  66. {
  67. int ret = strbuf_grow(sb, len);
  68. if (ret)
  69. return ret;
  70. memcpy(sb->buf + sb->len, data, len);
  71. return strbuf_setlen(sb, sb->len + len);
  72. }
  73. static int strbuf_addv(struct strbuf *sb, const char *fmt, va_list ap)
  74. {
  75. int len, ret;
  76. va_list ap_saved;
  77. if (!strbuf_avail(sb)) {
  78. ret = strbuf_grow(sb, 64);
  79. if (ret)
  80. return ret;
  81. }
  82. va_copy(ap_saved, ap);
  83. len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap);
  84. if (len < 0) {
  85. va_end(ap_saved);
  86. return len;
  87. }
  88. if (len > strbuf_avail(sb)) {
  89. ret = strbuf_grow(sb, len);
  90. if (ret) {
  91. va_end(ap_saved);
  92. return ret;
  93. }
  94. len = vsnprintf(sb->buf + sb->len, sb->alloc - sb->len, fmt, ap_saved);
  95. if (len > strbuf_avail(sb)) {
  96. pr_debug("this should not happen, your vsnprintf is broken");
  97. va_end(ap_saved);
  98. return -EINVAL;
  99. }
  100. }
  101. va_end(ap_saved);
  102. return strbuf_setlen(sb, sb->len + len);
  103. }
  104. int strbuf_addf(struct strbuf *sb, const char *fmt, ...)
  105. {
  106. va_list ap;
  107. int ret;
  108. va_start(ap, fmt);
  109. ret = strbuf_addv(sb, fmt, ap);
  110. va_end(ap);
  111. return ret;
  112. }
  113. ssize_t strbuf_read(struct strbuf *sb, int fd, ssize_t hint)
  114. {
  115. size_t oldlen = sb->len;
  116. size_t oldalloc = sb->alloc;
  117. int ret;
  118. ret = strbuf_grow(sb, hint ? hint : 8192);
  119. if (ret)
  120. return ret;
  121. for (;;) {
  122. ssize_t cnt;
  123. cnt = read(fd, sb->buf + sb->len, sb->alloc - sb->len - 1);
  124. if (cnt < 0) {
  125. if (oldalloc == 0)
  126. strbuf_release(sb);
  127. else
  128. strbuf_setlen(sb, oldlen);
  129. return cnt;
  130. }
  131. if (!cnt)
  132. break;
  133. sb->len += cnt;
  134. ret = strbuf_grow(sb, 8192);
  135. if (ret)
  136. return ret;
  137. }
  138. sb->buf[sb->len] = '\0';
  139. return sb->len - oldlen;
  140. }