buffers.c 4.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174
  1. /* buffers.c */
  2. #include "or.h"
  3. int buf_new(char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) {
  4. if (!pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */
  5. return -1;
  6. *pbuf = (char *)malloc(MAX_BUF_SIZE);
  7. if(!*pbuf)
  8. return -1;
  9. memset(*pbuf,0,MAX_BUF_SIZE);
  10. *pbuflen = MAX_BUF_SIZE;
  11. *pbuf_datalen = 0;
  12. return 0;
  13. }
  14. int buf_free(char *buf) {
  15. free(buf);
  16. return 0;
  17. }
  18. int read_to_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen, int *preached_eof) {
  19. /* grab from s, put onto buf, return how many bytes read */
  20. int read_result;
  21. char *buf;
  22. size_t buflen;
  23. size_t buf_datalen;
  24. if (!pbuf || !pbuflen || !pbuf_datalen || !preached_eof) /* invalid parameters */
  25. return -1 ;
  26. if(s<0) {
  27. log(LOG_DEBUG,"read_to_buf() received negative socket %d.",s);
  28. return -1;
  29. }
  30. /* this is the point where you would grow the buffer, if you want to */
  31. buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen;
  32. if (!buf) /* invalid parameter */
  33. return -1;
  34. read_result = read(s, buf+buf_datalen, buflen - buf_datalen);
  35. if (read_result < 0) {
  36. if(errno!=EAGAIN) { /* it's a real error */
  37. return -1;
  38. }
  39. return 0;
  40. } else if (read_result == 0) {
  41. log(LOG_DEBUG,"read_to_buf(): Encountered eof");
  42. *preached_eof = 1;
  43. return 0;
  44. } else { /* we read some bytes */
  45. *pbuf_datalen = buf_datalen + read_result;
  46. log(LOG_DEBUG,"read_to_buf(): Read %d bytes. %d on inbuf.",read_result, *pbuf_datalen);
  47. return read_result;
  48. }
  49. }
  50. int flush_buf(int s, char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) {
  51. /* push from buf onto s
  52. * then memmove to front of buf
  53. * return -1 or how many bytes remain on the buf */
  54. int write_result;
  55. char *buf;
  56. size_t buflen;
  57. size_t buf_datalen;
  58. if (!pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */
  59. return -1;
  60. if(s<0) {
  61. log(LOG_DEBUG,"flush_buf() received negative socket %d.",s);
  62. return -1;
  63. }
  64. if(*pbuf_datalen == 0) /* nothing to flush */
  65. return 0;
  66. /* this is the point where you would grow the buffer, if you want to */
  67. buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen;
  68. if (!buf) /* invalid parameter */
  69. return -1;
  70. write_result = write(s, buf, buf_datalen);
  71. if (write_result < 0) {
  72. if(errno!=EAGAIN) { /* it's a real error */
  73. return -1;
  74. }
  75. log(LOG_DEBUG,"flush_buf(): write() would block, returning.");
  76. return 0;
  77. } else {
  78. *pbuf_datalen -= write_result;
  79. memmove(buf, buf+write_result, *pbuf_datalen);
  80. log(LOG_DEBUG,"flush_buf(): flushed %d bytes, %d remain.",write_result,*pbuf_datalen);
  81. return *pbuf_datalen;
  82. }
  83. }
  84. int write_to_buf(char *string, size_t string_len,
  85. char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) {
  86. /* append string to buf (growing as needed, return -1 if "too big")
  87. * return total number of bytes on the buf
  88. */
  89. char *buf;
  90. size_t buflen;
  91. size_t buf_datalen;
  92. if (!string || !pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */
  93. return -1;
  94. /* this is the point where you would grow the buffer, if you want to */
  95. buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen;
  96. if (!buf) /* invalid parameter */
  97. return -1;
  98. if (string_len + buf_datalen > buflen) { /* we're out of luck */
  99. log(LOG_DEBUG, "write_to_buf(): buflen too small. Time to implement growing dynamic bufs.");
  100. return -1;
  101. }
  102. memcpy(buf+buf_datalen, string, string_len);
  103. *pbuf_datalen += string_len;
  104. log(LOG_DEBUG,"write_to_buf(): added %d bytes to buf (now %d total).",string_len, *pbuf_datalen);
  105. return *pbuf_datalen;
  106. }
  107. int fetch_from_buf(char *string, size_t string_len,
  108. char **pbuf, size_t *pbuflen, size_t *pbuf_datalen) {
  109. /* if there is string_len bytes in buf, write them onto string,
  110. * then memmove buf back (that is, remove them from buf) */
  111. char *buf;
  112. size_t buflen;
  113. size_t buf_datalen;
  114. if (!string || !pbuf || !pbuflen || !pbuf_datalen) /* invalid parameters */
  115. return -1;
  116. /* this is the point where you would grow the buffer, if you want to */
  117. buf = *pbuf, buflen = *pbuflen, buf_datalen = *pbuf_datalen;
  118. if (!buf) /* invalid parameter */
  119. return -1;
  120. if(string_len > buf_datalen) /* we want too much. sorry. */
  121. return -1;
  122. memcpy(string,buf,string_len);
  123. *pbuf_datalen -= string_len;
  124. memmove(buf, buf+string_len, *pbuf_datalen);
  125. return *pbuf_datalen;
  126. }