You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

278 lines
6.2 KiB

  1. #include "pEp_internal.h"
  2. #include <memory.h>
  3. #include <assert.h>
  4. DYNAMIC_API message *new_message(
  5. PEP_msg_direction dir,
  6. pEp_identity *from,
  7. identity_list *to,
  8. const char *shortmsg
  9. )
  10. {
  11. message *msg = calloc(1, sizeof(message));
  12. assert(msg);
  13. if (msg == NULL)
  14. return NULL;
  15. if (shortmsg) {
  16. msg->shortmsg = strdup(shortmsg);
  17. assert(msg->shortmsg);
  18. if (msg->shortmsg == NULL) {
  19. free(msg);
  20. return NULL;
  21. }
  22. }
  23. msg->dir = dir;
  24. msg->from = from;
  25. msg->to = to;
  26. stringpair_t version;
  27. version.key = "X-pEp-Version";
  28. version.value = PEP_VERSION;
  29. msg->opt_fields = new_stringpair_list(&version);
  30. if (msg->opt_fields == NULL) {
  31. free_message(msg);
  32. return NULL;
  33. }
  34. return msg;
  35. }
  36. DYNAMIC_API void free_message(message *msg)
  37. {
  38. if (msg) {
  39. free(msg->id);
  40. free(msg->shortmsg);
  41. free(msg->longmsg);
  42. free(msg->longmsg_formatted);
  43. free_bloblist(msg->attachments);
  44. free(msg->sent);
  45. free(msg->recv);
  46. free_identity(msg->from);
  47. free_identity_list(msg->to);
  48. free_identity(msg->recv_by);
  49. free_identity_list(msg->cc);
  50. free_identity_list(msg->bcc);
  51. free_identity_list(msg->reply_to);
  52. free_stringlist(msg->in_reply_to);
  53. free_stringlist(msg->references);
  54. free_stringlist(msg->keywords);
  55. free(msg->comments);
  56. free_stringpair_list(msg->opt_fields);
  57. free(msg);
  58. }
  59. }
  60. DYNAMIC_API message * message_dup(const message *src)
  61. {
  62. message * msg = NULL;
  63. pEp_identity * from = NULL;
  64. identity_list * to = NULL;
  65. assert(src);
  66. from = identity_dup(src->from);
  67. if (from == NULL)
  68. goto enomem;
  69. to = identity_list_dup(src->to);
  70. if (to == NULL)
  71. goto enomem;
  72. msg = new_message(src->dir, from, to, src->shortmsg);
  73. if (msg == NULL)
  74. goto enomem;
  75. if (src->id) {
  76. msg->id = strdup(src->id);
  77. assert(msg->id);
  78. if (msg->id == NULL)
  79. goto enomem;
  80. }
  81. if (src->longmsg) {
  82. msg->longmsg = strdup(src->longmsg);
  83. assert(msg->longmsg);
  84. if (msg->longmsg == NULL)
  85. goto enomem;
  86. }
  87. if (src->longmsg_formatted) {
  88. msg->longmsg_formatted = strdup(src->longmsg_formatted);
  89. assert(msg->longmsg_formatted);
  90. if (msg->longmsg_formatted == NULL)
  91. goto enomem;
  92. }
  93. if (src->attachments) {
  94. msg->attachments = bloblist_dup(src->attachments);
  95. if (msg->attachments == NULL)
  96. goto enomem;
  97. }
  98. msg->rawmsg_ref = src->rawmsg_ref;
  99. msg->rawmsg_size = src->rawmsg_size;
  100. if (src->sent) {
  101. msg->sent = malloc(sizeof(timestamp));
  102. if (msg->sent == NULL)
  103. goto enomem;
  104. memcpy(msg->sent, src->sent, sizeof(timestamp));
  105. }
  106. if (src->recv) {
  107. msg->recv = malloc(sizeof(timestamp));
  108. if (msg->recv == NULL)
  109. goto enomem;
  110. memcpy(msg->recv, src->recv, sizeof(timestamp));
  111. }
  112. if (src->recv_by) {
  113. msg->recv_by = identity_dup(src->recv_by);
  114. if (msg->recv_by == NULL)
  115. goto enomem;
  116. }
  117. if (src->cc) {
  118. msg->cc = identity_list_dup(src->cc);
  119. if (msg->cc == NULL)
  120. goto enomem;
  121. }
  122. if (src->bcc) {
  123. msg->bcc = identity_list_dup(src->bcc);
  124. if (msg->bcc == NULL)
  125. goto enomem;
  126. }
  127. if (src->reply_to) {
  128. msg->reply_to = identity_list_dup(src->reply_to);
  129. if (msg->reply_to == NULL)
  130. goto enomem;
  131. }
  132. if (src->in_reply_to) {
  133. msg->in_reply_to = stringlist_dup(src->in_reply_to);
  134. assert(msg->in_reply_to);
  135. if (msg->in_reply_to == NULL)
  136. goto enomem;
  137. }
  138. msg->refering_msg_ref = src->refering_msg_ref;
  139. if (src->references) {
  140. msg->references = stringlist_dup(src->references);
  141. if (msg->references == NULL)
  142. goto enomem;
  143. }
  144. if (src->refered_by) {
  145. msg->refered_by = message_ref_list_dup(src->refered_by);
  146. if (msg->refered_by == NULL)
  147. goto enomem;
  148. }
  149. if (src->keywords) {
  150. msg->keywords = stringlist_dup(src->keywords);
  151. if (msg->keywords == NULL)
  152. goto enomem;
  153. }
  154. if (src->comments) {
  155. msg->comments = strdup(src->comments);
  156. assert(msg->comments);
  157. if (msg->comments == NULL)
  158. goto enomem;
  159. }
  160. if (src->opt_fields) {
  161. msg->opt_fields = stringpair_list_dup(src->opt_fields);
  162. if (msg->opt_fields == NULL)
  163. goto enomem;
  164. }
  165. msg->enc_format = src->enc_format;
  166. return msg;
  167. enomem:
  168. if (msg) {
  169. free_message(msg);
  170. }
  171. else {
  172. free_identity(from);
  173. free_identity_list(to);
  174. }
  175. return NULL;
  176. }
  177. DYNAMIC_API message_ref_list *new_message_ref_list(message *msg)
  178. {
  179. message_ref_list *msg_list = calloc(1, sizeof(message_ref_list));
  180. assert(msg_list);
  181. if (msg_list == NULL)
  182. return NULL;
  183. msg_list->msg_ref = msg;
  184. return msg_list;
  185. }
  186. DYNAMIC_API void free_message_ref_list(message_ref_list *msg_list)
  187. {
  188. if (msg_list) {
  189. free_message_ref_list(msg_list->next);
  190. free(msg_list);
  191. }
  192. }
  193. DYNAMIC_API message_ref_list *message_ref_list_dup(
  194. const message_ref_list *src
  195. )
  196. {
  197. message_ref_list * msg_list = NULL;
  198. assert(src);
  199. msg_list = new_message_ref_list(src->msg_ref);
  200. if (msg_list == NULL)
  201. goto enomem;
  202. if (src->next) {
  203. msg_list->next = message_ref_list_dup(src->next);
  204. if (msg_list->next == NULL)
  205. goto enomem;
  206. }
  207. return msg_list;
  208. enomem:
  209. free_message_ref_list(msg_list);
  210. return NULL;
  211. }
  212. DYNAMIC_API message_ref_list *message_ref_list_add(message_ref_list *msg_list, message *msg)
  213. {
  214. assert(msg);
  215. if (msg_list == NULL)
  216. return new_message_ref_list(msg);
  217. if (msg_list->msg_ref == NULL) {
  218. msg_list->msg_ref = msg;
  219. return msg_list;
  220. }
  221. else if (msg_list->next == NULL) {
  222. msg_list->next = new_message_ref_list(msg);
  223. assert(msg_list->next);
  224. return msg_list->next;
  225. }
  226. else {
  227. return message_ref_list_add(msg_list->next, msg);
  228. }
  229. }