masqmail: fc731510cc9d src/parse.c

masqmail

view src/parse.c @ 141:fc731510cc9d

typo fixes in masqmail.route(5)

author	meillo@marmaro.de
date	Tue, 06 Jul 2010 19:01:41 +0200
parents	f671821d8222
children	899175e8dff0

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 */

19 #ifndef PARSE_TEST

20 #include "masqmail.h"

21 #endif

23 /* This is really dangerous. I hope that I was careful enough,

24 but maybe there is some malformed address possible that causes

25 this to segfault or be caught in endless loops.

27 If you find something like that, PLEASE mail the string to me

28 (no matter how idiotic it is), so that I can debug that.

29 Those things really should not happen.

30 */

32 static gchar *specials = "()<>@,;:\\\".[]`";

34 char *parse_error = NULL;

36 static gchar*

37 skip_comment(gchar * p)

38 {

40 #ifdef PARSE_TEST

41 g_print("skip_comment: %s\n", p);

42 #endif

44 p++;

45 while (*p && *p != ')') {

46 p++;

47 if (*p == '(')

48 p = skip_comment(p);

49 }

50 p++;

52 return p;

53 }

55 static gboolean

56 read_word(gchar * p, gchar ** b, gchar ** e)

57 {

58 #ifdef PARSE_TEST

59 g_print("read_word: %s\n", p);

60 #endif

61 /* eat leading spaces */

62 while (*p && isspace(*p))

63 p++;

65 *b = p;

66 /* b = &p; */

67 if (*p == '\"') {

68 /* quoted-string */

69 p++;

70 while (*p && (*p != '\"'))

71 p++;

72 p++;

73 } else {

74 /* atom */

75 while (*p && !strchr(specials, *p) && !iscntrl(*p) && !isspace(*p))

76 p++;

77 }

78 *e = p;

79 return TRUE;

80 }

82 static gboolean

83 read_word_with_dots(gchar * p, gchar ** b, gchar ** e)

84 {

85 gchar *b0 = p;

87 #ifdef PARSE_TEST

88 g_print("read_word_with_dots: %s\n", p);

89 #endif

90 while (TRUE) {

91 if (!read_word(p, b, e))

92 return FALSE;

93 p = *e;

94 if (*p != '.')

95 break;

96 p++;

97 }

98 *b = b0;

99 *e = p;

100 return TRUE;

101 }

102

103 static gboolean

104 read_domain(gchar * p, gchar ** b, gchar ** e)

105 {

106 #ifdef PARSE_TEST

107 g_print("read_domain: %s\n", p);

108 #endif

109 *b = p;

110 if (*p != '[') {

111 while (isalnum(*p) || (*p == '-') || (*p == '.'))

112 p++;

113 } else {

114 p++;

115 while (isalpha(*p) || (*p == '.'))

116 p++;

117 if (*p != ']') {

118 parse_error = g_strdup_printf("']' expected at end of literal address %s", *b);

119 return FALSE;

120 }

121 p++;

122 }

123 *e = p;

124 return TRUE;

125 }

126

127 gboolean

128 parse_address_rfc822(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,

129 gchar** domain_end, gchar** address_end)

130 {

131 gint angle_brackets = 0;

132

133 gchar *p = string;

134 gchar *b, *e;

135

136 *local_begin = *local_end = NULL;

137 *domain_begin = *domain_end = NULL;

138

139 /* might be some memory left from previous call: */

140 if (parse_error != NULL) {

141 g_free(parse_error);

142 parse_error = NULL;

143 }

144

145 /* leading spaces and angle brackets */

146 while (*p && (isspace(*p) || (*p == '<'))) {

147 if (*p == '<')

148 angle_brackets++;

149 p++;

150 }

151

152 if (*p) {

153 while (TRUE) {

154 if (read_word_with_dots(p, &b, &e)) {

155 p = e;

156 #ifdef PARSE_TEST

157 g_print("after read_word_with_dots: %s\n", p);

158 #endif

159 /* eat white spaces and comments */

160 while ((*p && (isspace(*p))) || (*p == '(')) {

161 if (*p == '(') {

162 if (!(p = skip_comment(p))) {

163 parse_error = g_strdup("missing right bracket ')'");

164 return FALSE;

165 }

166 } else

167 p++;

168 }

169 /* we now have a non-space char that is not

170 the beginning of a comment */

171

172 if (*p == '@') {

173 /* the last word was the local_part

174 of an addr-spec */

175 *local_begin = b;

176 *local_end = e;

177 #ifdef PARSE_TEST

178 g_print("found local part: %s\n", *local_begin);

179 #endif

180 if (*p == '@') {

181 p++; /* skip @ */

182 /* now the domain */

183 if (read_domain(p, &b, &e)) {

184 p = e;

185 *domain_begin = b;

186 *domain_end = e;

187 } else

188 return FALSE;

189 } else {

190 /* unqualified? */

191 *domain_begin = *domain_end = NULL;

192 }

193 break;

194 } else if (*p == '<') {

195 /* addr-spec follows */

196 while (isspace(*p) || (*p == '<')) {

197 if (*p == '<')

198 angle_brackets++;

199 p++;

200 }

201 if (read_word_with_dots(p, &b, &e)) {

202 p = e;

203 *local_begin = b;

204 *local_end = e;

205 #ifdef PARSE_TEST

206 g_print("found local part: %s\n", *local_begin);

207 #endif

208 } else

209 return FALSE;

210 if (*p == '@') {

211 p++;

212 if (read_domain(p, &b, &e)) {

213 p = e;

214 *domain_begin = b;

215 *domain_end = e;

216 } else

217 return FALSE;

218 } else {

219 /* may be unqualified address */

220 *domain_begin = *domain_end = NULL;

221 }

222 break;

223 } else if (!*p || *p == '>') {

224 *local_begin = b;

225 *local_end = e;

226 #ifdef PARSE_TEST

227 g_print("found local part: %s\n", *local_begin);

228 #endif

229 *domain_begin = *domain_end = NULL;

230 break;

231 } else if (strchr(specials, *p) || iscntrl(*p) || isspace(*p)) {

232 parse_error = g_strdup_printf("unexpected character: %c", *p);

233 return FALSE;

234 }

235 } else

236 return FALSE;

237 }

238 /* trailing spaces and angle brackets */

239 #ifdef PARSE_TEST

240 g_print("down counting trailing '>'\n");

241 #endif

242 while (*p && (isspace(*p) || (*p == '>'))) {

243 if (*p == '>')

244 angle_brackets--;

245 p++;

246 }

247

248 *address_end = p;

249

250 if (angle_brackets != 0) {

251 if (angle_brackets > 0)

252 parse_error = g_strdup("missing '>' at end of string");

253 else

254 parse_error = g_strdup("superfluous '>' at end of string");

255 return FALSE;

256 } else {

257 /* we successfully parsed the address */

258 return TRUE;

259 }

260 /* we never get here */

261 }

262 return FALSE;

263 }

264

265 gboolean

266 parse_address_rfc821(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,

267 gchar** domain_end, gchar** address_end)

268 {

269 gint angle_brackets = 0;

270

271 gchar *p = string;

272 gchar *b, *e;

273

274 *local_begin = *local_end = NULL;

275 *domain_begin = *domain_end = NULL;

276

277 /* might be some memory left from previous call: */

278 if (parse_error != NULL) {

279 g_free(parse_error);

280 parse_error = NULL;

281 }

282

283 /* leading spaces and angle brackets */

284 while (*p && (isspace(*p) || (*p == '<'))) {

285 if (*p == '<')

286 angle_brackets++;

287 p++;

288 }

289

290 if (*p) {

291 while (TRUE) {

292 if (read_word_with_dots(p, &b, &e)) {

293 p = e;

294 #ifdef PARSE_TEST

295 g_print("after read_word_with_dots: %s\n", p);

296 #endif

297 *local_begin = b;

298 *local_end = e;

299 #ifdef PARSE_TEST

300 g_print("found local part: %s\n", *local_begin);

301 g_print("local_end = %s\n", *local_end);

302 #endif

303 if (!(*p) || isspace(*p) || (*p == '>')) {

304 /* unqualified ? */

305 domain_begin = domain_end = NULL;

306 break;

307 } else if (*p == '@') {

308 p++;

309 if (read_domain(p, &b, &e)) {

310 p = e;

311 *domain_begin = b;

312 *domain_end = e;

313 }

314 break;

315 } else {

316 parse_error = g_strdup_printf ("unexpected character after local part '%c'", *p);

317 return FALSE;

318 }

319 } else

320 return FALSE;

321 }

322

323 /* trailing spaces and angle brackets */

324 #ifdef PARSE_TEST

325 g_print("down counting trailing '>'\n");

326 #endif

327 while (*p && (isspace(*p) || (*p == '>'))) {

328 if (*p == '>')

329 angle_brackets--;

330 p++;

331 }

332 *address_end = p;

333

334 if (angle_brackets != 0) {

335 if (angle_brackets > 0)

336 parse_error = g_strdup("missing '>' at end of string");

337 else

338 parse_error = g_strdup("superfluous '>' at end of string");

339 return FALSE;

340 } else {

341 /* we successfully parsed the address */

342 return TRUE;

343 }

344 /* we never get here */

345 }

346 return FALSE;

347 }

348

349 /*

350 allocate address, reading from string.

351 On failure, returns NULL.

352 after call, end contains a pointer to the end of the parsed string

353 end may be NULL, if we are not interested.

354

355 parses both rfc 821 and rfc 822 addresses, depending on flag is_rfc821

356 */

357 address*

358 _create_address(gchar * string, gchar ** end, gboolean is_rfc821)

359 {

360 gchar *loc_beg, *loc_end;

361 gchar *dom_beg, *dom_end;

362 gchar *addr_end;

363

364 if (string && (string[0] == 0)) {

365 address *addr = g_malloc(sizeof(address));

366 addr->address = g_strdup("");

367 addr->local_part = g_strdup("");

368 addr->domain = g_strdup(""); /* 'NULL' address (failure notice),

369 "" makes sure it will not be qualified with a hostname */

370 return addr;

371 }

372

373 if (is_rfc821

374 ? parse_address_rfc821(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end)

375 : parse_address_rfc822(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end))

376 {

377 address *addr = g_malloc(sizeof(address));

378 gchar *p = addr_end;

379

380 memset(addr, 0, sizeof(address));

381

382 if (loc_beg[0] == '|') {

383 parse_error = g_strdup("no pipe allowed for RFC 822/821 address");

384 return NULL;

385 }

386

387 while (*p && (*p != ','))

388 p++;

389 addr->address = g_strndup(string, p - string);

390

391 addr->local_part = g_strndup(loc_beg, loc_end - loc_beg);

392

393 #ifdef PARSE_TEST

394 g_print("addr->local_part = %s\n", addr->local_part);

395 #endif

396

397 if (dom_beg != NULL) {

398 addr->domain = g_strndup(dom_beg, dom_end - dom_beg);

399 } else {

400 if (addr->local_part[0] == 0)

401 addr->domain = g_strdup(""); /* 'NULL' address (failure notice),

402 "" makes sure it will not be qualified with a hostname */

403 else

404 addr->domain = NULL;

405 }

406

407 if (end != NULL)

408 *end = p;

409

410 #ifndef PARSE_TEST

411 addr_unmark_delivered(addr);

412 #endif

413

414 return addr;

415 }

416 return NULL;

417 }

418

419 address*

420 create_address_rfc822(gchar * string, gchar ** end)

421 {

422 return _create_address(string, end, FALSE);

423 }

424

425 address*

426 create_address_rfc821(gchar * string, gchar ** end)

427 {

428 return _create_address(string, end, TRUE);

429 }

430

431 GList*

432 addr_list_append_rfc822(GList * addr_list, gchar * string, gchar * domain)

433 {

434 gchar *p = string;

435 gchar *end;

436

437 while (*p) {

438 address *addr = _create_address(p, &end, FALSE);

439 if (addr) {

440 if (domain)

441 if (addr->domain == NULL)

442 addr->domain = g_strdup(domain);

443

444 addr_list = g_list_append(addr_list, addr);

445 p = end;

446 } else

447 break;

448 while (*p == ',' || isspace(*p))

449 p++;

450 }

451 return addr_list;

452 }