masqmail: 2ffcd38ccf53 src/header.c

masqmail

view src/header.c @ 302:2ffcd38ccf53

improved unused function header_fold()

author	markus schnalke <meillo@marmaro.de>
date	Thu, 09 Dec 2010 17:50:25 -0300
parents	55c530a83d51
children	3e3c280ca5b2

line source

1 /* MasqMail

4 This program is free software; you can redistribute it and/or modify

5 it under the terms of the GNU General Public License as published by

6 the Free Software Foundation; either version 2 of the License, or

7 (at your option) any later version.

9 This program is distributed in the hope that it will be useful,

10 but WITHOUT ANY WARRANTY; without even the implied warranty of

11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

12 GNU General Public License for more details.

14 You should have received a copy of the GNU General Public License

15 along with this program; if not, write to the Free Software

16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

17 */

18 #include "masqmail.h"

20 header_name header_names[] = {

21 {"From", HEAD_FROM,},

22 {"Sender", HEAD_SENDER,},

23 {"To", HEAD_TO,},

24 {"Cc", HEAD_CC,},

25 {"Bcc", HEAD_BCC,},

26 {"Date", HEAD_DATE,},

27 {"Message-Id", HEAD_MESSAGE_ID,},

28 {"Reply-To", HEAD_REPLY_TO,},

29 {"Subject", HEAD_SUBJECT,},

30 {"Return-Path", HEAD_RETURN_PATH,},

31 {"Envelope-To", HEAD_ENVELOPE_TO,},

32 {"Received", HEAD_RECEIVED},

33 };

35 /* this was borrowed from exim and slightly changed */

36 gchar*

37 rec_timestamp()

38 {

39 static gchar buf[64];

40 int len;

42 time_t now = time(NULL);

43 struct tm *t = localtime(&now);

45 int diff_hour, diff_min;

46 struct tm local;

47 struct tm *gmt;

49 memcpy(&local, t, sizeof(struct tm));

50 gmt = gmtime(&now);

51 diff_min = 60 * (local.tm_hour - gmt->tm_hour) + local.tm_min - gmt->tm_min;

52 if (local.tm_year != gmt->tm_year) {

53 diff_min += (local.tm_year > gmt->tm_year) ? 1440 : -1440;

54 } else if (local.tm_yday != gmt->tm_yday) {

55 diff_min += (local.tm_yday > gmt->tm_yday) ? 1440 : -1440;

56 }

57 diff_hour = diff_min / 60;

58 diff_min = abs(diff_min - diff_hour * 60);

60 len = strftime(buf, sizeof(buf), "%a, ", &local);

61 g_snprintf(buf + len, sizeof(buf) - len, "%02d ", local.tm_mday);

62 len += strlen(buf + len);

63 len += strftime(buf + len, sizeof(buf) - len, "%b %Y %H:%M:%S", &local);

64 g_snprintf(buf + len, sizeof(buf) - len, " %+03d%02d", diff_hour, diff_min);

66 return buf;

67 }

69 /* finds list of headers matching id

70 if id == HEAD_UNKNOWN and header == NULL finds all unknown headers

71 else finds all headers matching header

72 */

73 GList*

74 find_header(GList * hdr_list, header_id id, gchar * hdr_str)

75 {

76 GList *found_list = NULL;

77 GList *node;

79 if ((id != HEAD_UNKNOWN) || !hdr_str) {

80 foreach(hdr_list, node) {

81 header *hdr = (header *) (node->data);

82 if (hdr->id == id) {

83 found_list = g_list_append(found_list, hdr);

84 }

85 }

86 return found_list;

87 }

89 foreach(hdr_list, node) {

90 header *hdr = (header *) (node->data);

91 gchar buf[64], *q = buf, *p = hdr->header;

93 while (*p != ':' && q < buf+sizeof(buf)-1 && *p) {

94 *(q++) = *(p++);

95 }

96 *q = '\0';

98 if (strcasecmp(buf, hdr_str) == 0) {

99 found_list = g_list_append(found_list, hdr);

100 }

101 }

102 return found_list;

103 }

104

105 void

106 header_unfold(header * hdr)

107 {

108 char *src = hdr->header;

109 char *dest = src;

110 char *p;

111

112 p = strchr(src, '\n');

113 if (!p || !p[1]) {

114 /* no folded header */

115 return;

116 }

117

118 while (*src) {

119 if (*src == '\n') {

120 /* ignore */

121 src++;

122 } else {

123 /* copy */

124 *(dest++) = *(src++);

125 }

126 }

127 *(dest++) = '\n';

128 *(dest++) = '\0';

129 }

130

131 #define MAX_HDR_LEN 72

132 void

133 header_fold(header * hdr)

134 {

135 gint len = strlen(hdr->header);

136 gchar *p, *q;

137 gchar *tmp_hdr;

138 int valueoffset;

139

140 if (len < MAX_HDR_LEN) {

141 /* we don't need to do anything */

142 return;

143 }

144

145 /* the position in hdr->header where the value part starts */

146 valueoffset = hdr->value - hdr->header;

147

148 /* TODO: size is only calculated roughly */

149 /* size is probably overestimated, but so we are on the safe side */

150 /* (as much as we already have + chars inserted per break * number

151 of breaks + some more) */

152 tmp_hdr = g_malloc(len + 2 * (len/MAX_HDR_LEN) + 10);

153

154 p = hdr->header;

155 q = tmp_hdr;

156

157 if (p[len - 1] == '\n') {

158 p[len - 1] = '\0';

159 }

160

161 while (*p) {

162 gint i, l;

163 gchar *pp;

164

165 /* look forward and find potential break points */

166 i = 0;

167 l = -1;

168 pp = p;

169 while (*pp && (i < MAX_HDR_LEN)) {

170 if ((*pp == ' ') || (*pp == '\t')) {

171 l = i;

172 }

173 pp++;

174 i++;

175 }

176 if (!*pp) {

177 l = pp - p; /* take rest, if EOS found */

178 }

179

180 if (l == -1) {

181 /* no potential break point was found within

182 MAX_HDR_LEN so advance further until the next */

183 while (*pp && *pp != ' ' && *pp != '\t') {

184 pp++;

185 i++;

186 }

187 l = i;

188 }

189

190 /* copy */

191 i = 0;

192 while (i < l) {

193 *(q++) = *(p++);

194 i++;

195 }

196 *(q++) = '\n';

197 *(q++) = *(p++); /* this is either space, tab or 0 */

198 /* *(q++) = '\t'; */

199 }

200

201 g_free(hdr->header);

202 hdr->header = tmp_hdr;

203 hdr->value = hdr->header + valueoffset;

204 }

205

206 header*

207 create_header(header_id id, gchar * fmt, ...)

208 {

209 gchar *p;

210 header *hdr;

211 va_list args;

212 va_start(args, fmt);

213

214 /* g_malloc() calls exit on failure */

215 hdr = g_malloc(sizeof(header));

216

217 hdr->id = id;

218 hdr->header = g_strdup_vprintf(fmt, args);

219 hdr->value = NULL;

220

221 /* value shall point to the first non-whitespace char in the

222 value part of the header line (i.e. after the first colon) */

223 p = strchr(hdr->header, ':');

224 if (p) {

225 p++;

226 while (*p == ' ' || *p == '\t' || *p == '\n') {

227 p++;

228 }

229 hdr->value = (*p) ? p : NULL;

230 }

231

232 DEBUG(3) debugf("create_header(): hdr: `%s'\n", hdr->header);

233 DEBUG(3) debugf("create_header(): val: `%s'\n", hdr->value);

234

235 va_end(args);

236 return hdr;

237 }

238

239 void

240 destroy_header(header * hdr)

241 {

242 if (hdr) {

243 if (hdr->header) {

244 g_free(hdr->header);

245 }

246 g_free(hdr);

247 }

248 }

249

250 header*

251 copy_header(header * hdr)

252 {

253 header *new_hdr = NULL;

254

255 if (hdr) {

256 new_hdr = g_malloc(sizeof(header));

257 new_hdr->id = hdr->id;

258 new_hdr->header = g_strdup(hdr->header);

259 new_hdr->value = new_hdr->header + (hdr->value - hdr->header);

260 }

261 return new_hdr;

262 }

263

264 header*

265 get_header(gchar * line)

266 {

267 gchar *p = line;

268 gchar buf[64], *q = buf;

269 gint i;

270 header *hdr;

271

272 while (*p && (*p != ':') && (q < buf+sizeof(buf)-1)) {

273 *(q++) = *(p++);

274 }

275 *q = '\0';

276

277 if (*p != ':') {

278 return NULL;

279 }

280

281 hdr = g_malloc(sizeof(header));

282

283 hdr->value = NULL;

284 p++;

285

286 while (*p && (*p == ' ' || *p == '\t')) {

287 p++;

288 }

289 hdr->value = p;

290 /* Note: an empty value can also mean that it's only the first part

291 of a folded header line */

292

293 for (i = 0; i < HEAD_NUM_IDS; i++) {

294 if (strcasecmp(header_names[i].header, buf) == 0) {

295 break;

296 }

297 }

298 hdr->id = (header_id) i;

299 hdr->header = g_strdup(line);

300 hdr->value = hdr->header + (hdr->value - line);

301

302 DEBUG(4) debugf("header: %d = %s", hdr->id, hdr->header);

303 /* Note: This only outputs the first line if the header is folded */

304

305 return hdr;

306 }