chiark - git - mdw - ezmlm/blob - sub

1 /*$Id: subscribe.c,v 1.3 1999/10/07 23:31:01 lindberg Exp $*/

2 /*$Name: ezmlm-idx-040 $*/

3 #include "stralloc.h"

4 #include "getln.h"

5 #include "readwrite.h"

6 #include "substdio.h"

7 #include "strerr.h"

8 #include "open.h"

9 #include "byte.h"

10 #include "case.h"

11 #include "lock.h"

12 #include "error.h"

13 #include "subscribe.h"

14 #include "uint32.h"

15 #include "fmt.h"

16 #include "errtxt.h"

17 #include "log.h"

18 #include "idx.h"

19 #include <stdlib.h>

20 #include <unistd.h>

21 #include <libpq-fe.h>

23 static void die_nomem(fatal)

24 char *fatal;

25 {

26 strerr_die2x(111,fatal,ERR_NOMEM);

27 }

29 static stralloc addr = {0};

30 static stralloc lcaddr = {0};

31 static stralloc line = {0};

32 static stralloc domain = {0};

33 static stralloc logline = {0};

34 static stralloc fnnew = {0};

35 static stralloc fn = {0};

36 static stralloc fnlock = {0};

38 void die_read(fatal)

39 char *fatal;

40 {

41 strerr_die4sys(111,fatal,ERR_READ,fn.s,": ");

42 }

44 void die_write(fatal)

45 char *fatal;

46 {

47 strerr_die4sys(111,fatal,ERR_WRITE,fnnew.s,": ");

48 }

50 static int fd;

51 static substdio ss;

52 static char ssbuf[256];

53 static int fdnew;

54 static substdio ssnew;

55 static char ssnewbuf[256];

57 int subscribe(dbname,userhost,flagadd,comment,event,flagsql,

58 forcehash,tab,fatal)

59 /* add (flagadd=1) or remove (flagadd=0) userhost from the subscr. database */

60 /* dbname. Comment is e.g. the subscriber from line or name. It is added to */

61 /* the log. Event is the action type, e.g. "probe", "manual", etc. The */

62 /* direction (sub/unsub) is inferred from flagadd. Returns 1 on success, 0 */

63 /* on failure. If flagmysql is set and the file "sql" is found in the */

64 /* directory dbname, it is parsed and a mysql db is assumed. if forcehash is */

65 /* >=0 it is used in place of the calculated hash. This makes it possible to */

66 /* add addresses with a hash that does not exist. forcehash has to be 0..99. */

67 /* for unsubscribes, the address is only removed if forcehash matches the */

68 /* actual hash. This way, ezmlm-manage can be prevented from touching certain*/

69 /* addresses that can only be removed by ezmlm-unsub. Usually, this would be */

70 /* used for sublist addresses (to avoid removal) and sublist aliases (to */

71 /* prevent users from subscribing them (although the cookie mechanism would */

72 /* prevent the resulting duplicate message from being distributed. */

74 char *dbname;

75 char *userhost;

76 int flagadd;

77 char *comment;

78 char *event;

79 int flagsql;

80 int forcehash;

81 char *tab;

82 char *fatal;

83 {

84 int fdlock;

86 PGresult *result;

88 char *cpat;

89 char szhash[3] = "00";

90 char *r = (char *) 0;

91 char *table = (char *) 0;

92 char **ptable = &table;

94 unsigned int j;

95 uint32 h,lch;

96 unsigned char ch,lcch;

97 int match;

98 int flagwasthere;

100 if (userhost[str_chr(userhost,'\n')])

101 strerr_die2x(100,fatal,ERR_ADDR_NL);

102

103 if (tab) ptable = &tab;

104

105 if (!flagsql || (r = opensql(dbname,ptable))) {

106 if (r && *r) strerr_die2x(111,fatal,r);

107 /* fallback to local db */

108 if (!stralloc_copys(&addr,"T")) die_nomem(fatal);

109 if (!stralloc_cats(&addr,userhost)) die_nomem(fatal);

110 if (addr.len > 401)

111 strerr_die2x(100,fatal,ERR_ADDR_LONG);

112

113 j = byte_rchr(addr.s,addr.len,'@');

114 if (j == addr.len)

115 strerr_die2x(100,fatal,ERR_ADDR_AT);

116 case_lowerb(addr.s + j + 1,addr.len - j - 1);

117 if (!stralloc_copy(&lcaddr,&addr)) die_nomem(fatal);

118 case_lowerb(lcaddr.s + 1,j - 1); /* make all-lc version of address */

119

120 if (forcehash >= 0 && forcehash <= 52) {

121 ch = lcch = (unsigned char) forcehash;

122 } else {

123 h = 5381;

124 lch = h;

125 for (j = 0;j < addr.len;++j) {

126 h = (h + (h << 5)) ^ (uint32) (unsigned char) addr.s[j];

127 lch = (lch + (lch << 5)) ^ (uint32) (unsigned char) lcaddr.s[j];

128 }

129 lcch = 64 + (lch % 53);

130 ch = 64 + (h % 53);

131 }

132

133 if (!stralloc_0(&addr)) die_nomem(fatal);

134 if (!stralloc_0(&lcaddr)) die_nomem(fatal);

135 if (!stralloc_copys(&fn,dbname)) die_nomem(fatal);

136 if (!stralloc_copys(&fnlock,dbname)) die_nomem(fatal);

137

138 if (!stralloc_cats(&fn,"/subscribers/")) die_nomem(fatal);

139 if (!stralloc_catb(&fn,&lcch,1)) die_nomem(fatal);

140 if (!stralloc_copy(&fnnew,&fn)) die_nomem(fatal);

141 /* code later depends on fnnew = fn + 'n' */

142 if (!stralloc_cats(&fnnew,"n")) die_nomem(fatal);

143 if (!stralloc_cats(&fnlock,"/lock")) die_nomem(fatal);

144 if (!stralloc_0(&fnnew)) die_nomem(fatal);

145 if (!stralloc_0(&fn)) die_nomem(fatal);

146 if (!stralloc_0(&fnlock)) die_nomem(fatal);

147

148 fdlock = open_append(fnlock.s);

149 if (fdlock == -1)

150 strerr_die4sys(111,fatal,ERR_OPEN,fnlock.s,": ");

151 if (lock_ex(fdlock) == -1)

152 strerr_die4sys(111,fatal,ERR_OBTAIN,fnlock.s,": ");

153

154 /* do lower case hashed version first */

155 fdnew = open_trunc(fnnew.s);

156 if (fdnew == -1) die_write(fatal);

157 substdio_fdbuf(&ssnew,write,fdnew,ssnewbuf,sizeof(ssnewbuf));

158

159 flagwasthere = 0;

160

161 fd = open_read(fn.s);

162 if (fd == -1) {

163 if (errno != error_noent) { close(fdnew); die_read(fatal); }

164 }

165 else {

166 substdio_fdbuf(&ss,read,fd,ssbuf,sizeof(ssbuf));

167

168 for (;;) {

169 if (getln(&ss,&line,&match,'\0') == -1) {

170 close(fd); close(fdnew); die_read(fatal);

171 }

172 if (!match) break;

173 if (line.len == addr.len)

174 if (!case_diffb(line.s,line.len,addr.s)) {

175 flagwasthere = 1;

176 if (!flagadd)

177 continue;

178 }

179 if (substdio_bput(&ssnew,line.s,line.len) == -1) {

180 close(fd); close(fdnew); die_write(fatal);

181 }

182 }

183

184 close(fd);

185 }

186

187 if (flagadd && !flagwasthere)

188 if (substdio_bput(&ssnew,addr.s,addr.len) == -1) {

189 close(fdnew); die_write(fatal);

190 }

191

192 if (substdio_flush(&ssnew) == -1) { close(fdnew); die_write(fatal); }

193 if (fsync(fdnew) == -1) { close(fdnew); die_write(fatal); }

194 close(fdnew);

195

196 if (rename(fnnew.s,fn.s) == -1)

197 strerr_die6sys(111,fatal,ERR_MOVE,fnnew.s," to ",fn.s,": ");

198

199 if ((ch == lcch) || flagwasthere) {

200 close(fdlock);

201 if (flagadd ^ flagwasthere) {

202 if (!stralloc_0(&addr)) die_nomem(fatal);

203 log(dbname,event,addr.s+1,comment);

204 return 1;

205 }

206 return 0;

207 }

208

209 /* If unsub and not found and hashed differ, OR */

210 /* sub and not found (so added with new hash) */

211 /* do the 'case-dependent' hash */

212

213 fn.s[fn.len - 2] = ch;

214 fnnew.s[fnnew.len - 3] = ch;

215 fdnew = open_trunc(fnnew.s);

216 if (fdnew == -1) die_write(fatal);

217 substdio_fdbuf(&ssnew,write,fdnew,ssnewbuf,sizeof(ssnewbuf));

218

219 fd = open_read(fn.s);

220 if (fd == -1) {

221 if (errno != error_noent) { close(fdnew); die_read(fatal); }

222 } else {

223 substdio_fdbuf(&ss,read,fd,ssbuf,sizeof(ssbuf));

224

225 for (;;) {

226 if (getln(&ss,&line,&match,'\0') == -1)

227 { close(fd); close(fdnew); die_read(fatal); }

228 if (!match) break;

229 if (line.len == addr.len)

230 if (!case_diffb(line.s,line.len,addr.s)) {

231 flagwasthere = 1;

232 continue; /* always want to remove from case-sensitive hash */

233 }

234 if (substdio_bput(&ssnew,line.s,line.len) == -1)

235 { close(fd); close(fdnew); die_write(fatal); }

236 }

237

238 close(fd);

239 }

240

241 if (substdio_flush(&ssnew) == -1) { close(fdnew); die_write(fatal); }

242 if (fsync(fdnew) == -1) { close(fdnew); die_write(fatal); }

243 close(fdnew);

244

245 if (rename(fnnew.s,fn.s) == -1)

246 strerr_die6sys(111,fatal,ERR_MOVE,fnnew.s," to ",fn.s,": ");

247

248 close(fdlock);

249 if (flagadd ^ flagwasthere) {

250 if (!stralloc_0(&addr)) die_nomem(fatal);

251 log(dbname,event,addr.s+1,comment);

252 return 1;

253 }

254 return 0;

255

256 } else { /* SQL version */

257 domain.len = 0; /* clear domain */

258 /* lowercase and check address */

259 if (!stralloc_copys(&addr,userhost)) die_nomem(fatal);

260 if (addr.len > 255) /* this is 401 in std ezmlm. 255 */

261 /* should be plenty! */

262 strerr_die2x(100,fatal,ERR_ADDR_LONG);

263 j = byte_rchr(addr.s,addr.len,'@');

264 if (j == addr.len)

265 strerr_die2x(100,fatal,ERR_ADDR_AT);

266 cpat = addr.s + j;

267 case_lowerb(cpat + 1,addr.len - j - 1);

268

269 if (forcehash < 0) {

270 if (!stralloc_copy(&lcaddr,&addr)) die_nomem(fatal);

271 case_lowerb(lcaddr.s,j); /* make all-lc version of address */

272 h = 5381;

273 for (j = 0;j < lcaddr.len;++j) {

274 h = (h + (h << 5)) ^ (uint32) (unsigned char) lcaddr.s[j];

275 }

276 ch = (h % 53); /* 0 - 52 */

277 } else

278 ch = (forcehash % 100);

279

280 szhash[0] = '0' + ch / 10; /* hash for sublist split */

281 szhash[1] = '0' + (ch % 10);

282

283 if (flagadd) {

284 if (!stralloc_copys(&line,"SELECT address FROM ")) die_nomem(fatal);

285 if (!stralloc_cats(&line,table)) die_nomem(fatal);

286 if (!stralloc_cats(&line," WHERE address ~* '^")) die_nomem(fatal);

287 if (!stralloc_cat(&line,&addr)) die_nomem(fatal); /* addr */

288 if (!stralloc_cats(&line,"$'")) die_nomem(fatal);

289 if (!stralloc_0(&line)) die_nomem(fatal);

290 result = PQexec(psql,line.s);

291 if (result == NULL)

292 strerr_die2x(111,fatal,PQerrorMessage(psql));

293 if (PQresultStatus(result) != PGRES_TUPLES_OK)

294 strerr_die2x(111,fatal,PQresultErrorMessage(result));

295

296 if (PQntuples(result)>0) { /* there */

297 PQclear(result);

298 return 0; /* there */

299 } else { /* not there */

300 PQclear(result);

301 if (!stralloc_copys(&line,"INSERT INTO ")) die_nomem(fatal);

302 if (!stralloc_cats(&line,table)) die_nomem(fatal);

303 if (!stralloc_cats(&line," (address,hash) VALUES ('"))

304 die_nomem(fatal);

305 if (!stralloc_cat(&line,&addr)) die_nomem(fatal); /* addr */

306 if (!stralloc_cats(&line,"',")) die_nomem(fatal);

307 if (!stralloc_cats(&line,szhash)) die_nomem(fatal); /* hash */

308 if (!stralloc_cats(&line,")")) die_nomem(fatal);

309 if (!stralloc_0(&line)) die_nomem(fatal);

310 result = PQexec(psql,line.s);

311 if (result == NULL)

312 strerr_die2x(111,fatal,PQerrorMessage(psql));

313 if (PQresultStatus(result) != PGRES_COMMAND_OK)

314 strerr_die2x(111,fatal,PQresultErrorMessage(result));

315 }

316 } else { /* unsub */

317 if (!stralloc_copys(&line,"DELETE FROM ")) die_nomem(fatal);

318 if (!stralloc_cats(&line,table)) die_nomem(fatal);

319 if (!stralloc_cats(&line," WHERE address ~* '^")) die_nomem(fatal);

320 if (!stralloc_cat(&line,&addr)) die_nomem(fatal); /* addr */

321 if (forcehash >= 0) {

322 if (!stralloc_cats(&line,"$' AND hash=")) die_nomem(fatal);

323 if (!stralloc_cats(&line,szhash)) die_nomem(fatal);

324 } else {

325 if (!stralloc_cats(&line,"$' AND hash BETWEEN 0 AND 52"))

326 die_nomem(fatal);

327 }

328

329 if (!stralloc_0(&line)) die_nomem(fatal);

330 result = PQexec(psql,line.s);

331 if (result == NULL)

332 strerr_die2x(111,fatal,PQerrorMessage(psql));

333 if (PQresultStatus(result) != PGRES_COMMAND_OK)

334 strerr_die2x(111,fatal,PQresultErrorMessage(result));

335 if (atoi(PQcmdTuples(result))<1)

336 return 0; /* address wasn't there*/

337 PQclear(result);

338 }

339

340 /* log to subscriber log */

341 /* INSERT INTO t_slog (address,edir,etype,fromline) */

342 /* VALUES('address',{'+'|'-'},'etype','[comment]') */

343

344 if (!stralloc_copys(&logline,"INSERT INTO ")) die_nomem(fatal);

345 if (!stralloc_cats(&logline,table)) die_nomem(fatal);

346 if (!stralloc_cats(&logline,

347 "_slog (address,edir,etype,fromline) VALUES ('")) die_nomem(fatal);

348 if (!stralloc_cat(&logline,&addr)) die_nomem(fatal);

349 if (flagadd) { /* edir */

350 if (!stralloc_cats(&logline,"','+','")) die_nomem(fatal);

351 } else {

352 if (!stralloc_cats(&logline,"','-','")) die_nomem(fatal);

353 }

354 if (*(event + 1)) /* ezmlm-0.53 uses '' for ezmlm-manage's work */

355 if (!stralloc_catb(&logline,event+1,1)) die_nomem(fatal); /* etype */

356 if (!stralloc_cats(&logline,"','")) die_nomem(fatal);

357 if (comment && *comment) {

358 if (!stralloc_cats(&logline,comment)) die_nomem(fatal);

359 }

360 if (!stralloc_cats(&logline,"')")) die_nomem(fatal);

361

362 if (!stralloc_0(&logline)) die_nomem(fatal);

363 result = PQexec(psql,logline.s); /* log (ignore errors) */

364 PQclear(result);

365

366 if (!stralloc_0(&addr))

367 ; /* ignore errors */

368 log(dbname,event,addr.s,comment); /* also log to old log */

369 return 1; /* desired effect */

370 }

371 }