开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > WEB邮件程序 > 查看源码
authdaemond.c
资源名称：sqwebmail-0.37a.38pre2.tar.gz　[点击查看]
上传用户：s81996212
上传日期：2007-01-04
资源大小：722k
文件大小：11k
源码类别：

WEB邮件程序

开发平台：

C/C++

authdaemond.c：源码内容
  1. /*
  2. ** Copyright 2000 Double Precision, Inc.  See COPYING for
  3. ** distribution information.
  4. */
  6. #include "config.h"
  7. #include <sys/types.h>
  8. #include <sys/stat.h>
  9. #include <sys/socket.h>
  10. #include <sys/un.h>
  11. #include <sys/time.h>
  12. #include <sys/wait.h>
  13. #include <unistd.h>
  14. #include <stdlib.h>
  15. #include <stdio.h>
  16. #include <errno.h>
  17. #include <signal.h>
  18. #include <fcntl.h>
  19. #include <ctype.h>
  20. #include <syslog.h>
  21. #include "numlib/numlib.h"
  22. #include "liblock/config.h"
  23. #include "liblock/liblock.h"
  24. #include "auth.h"
  25. #include "authmod.h"
  26. #include "authdaemonrc.h"
  28. static const char rcsid[]="$Id: authdaemond.c,v 1.7 2000/05/04 01:31:31 mrsam Exp $";
  30. #ifndef SOMAXCONN
  31. #define SOMAXCONN 5
  32. #endif
  34. #if HAVE_HMACLIB
  35. #include        "../libhmac/hmac.h"
  36. #include        "cramlib.h"
  37. #endif
  39. #include "authstaticlist.h"
  41. /* First, prototype the functions */
  43. #define AUTHSTATIC(name, func, prefunc, cleanupfunc) 
  44. extern char *func(const char *, const char *, char *, int, 
  45. void (*)(struct authinfo *, void *), void *); 
  46. extern int prefunc(const char *, const char *, 
  47. int (*)(struct authinfo *, void *), void *arg); 
  48. extern void cleanupfunc();
  50. DAEMON_STATIC_LIST
  52. #undef  AUTHSTATIC
  54. /* Now, we can build the list */
  56. #define AUTHSTATIC(name, func, prefunc, cleanupfunc) 
  57. { name, func, prefunc, cleanupfunc, 0},
  59. struct authstaticinfo authstaticlist[] = {
  61. DAEMON_STATIC_LIST
  63.         {0, 0, 0, 0} };
  65. static char *authmodulelist;
  66. static unsigned ndaemons;
  68. static int mksocket()
  69. {
  70. int fd=socket(PF_UNIX, SOCK_STREAM, 0);
  71. struct sockaddr_un skun;
  73. if (fd < 0) return (-1);
  74. skun.sun_family=AF_UNIX;
  75. strcpy(skun.sun_path, AUTHDAEMONSOCK);
  76. strcat(skun.sun_path, ".tmp");
  77. unlink(skun.sun_path);
  78. if (bind(fd, (const struct sockaddr *)&skun, sizeof(skun)) ||
  79. listen(fd, SOMAXCONN) ||
  80. chmod(skun.sun_path, 0777) ||
  81. rename(skun.sun_path, AUTHDAEMONSOCK) ||
  82. fcntl(fd, F_SETFL, O_NONBLOCK) < 0)
  83. {
  84. perror(AUTHDAEMONSOCK);
  85. close(fd);
  86. return (-1);
  87. }
  88. return (fd);
  89. }
  91. static int readconfig()
  92. {
  93. char buf[BUFSIZ];
  94. FILE *fp;
  95. char *modlist=0;
  96. unsigned daemons=1;
  98. if ((fp=fopen(AUTHDAEMONRC, "r")) == NULL)
  99. {
  100. perror(AUTHDAEMONRC);
  101. return (-1);
  102. }
  104. while (fgets(buf, sizeof(buf), fp))
  105. {
  106. char *p=strchr(buf, 'n'), *q;
  108. if (!p)
  109. {
  110. int c;
  112. while ((c=getc(fp)) >= 0 && c != 'n')
  113. ;
  114. }
  115. else *p=0;
  116. if ((p=strchr(buf, '#')) != 0) *p=0;
  118. for (p=buf; *p; p++)
  119. if (!isspace((int)(unsigned char)*p))
  120. break;
  121. if (*p == 0) continue;
  123. if ((p=strchr(buf, '=')) == 0)
  124. {
  125. fprintf(stderr, "Bad line in %s: %sn",
  126. AUTHDAEMONRC, buf);
  127. fclose(fp);
  128. if (modlist)
  129. free(modlist);
  130. return (-1);
  131. }
  132. *p++=0;
  133. while (*p && isspace((int)(unsigned char)*p))
  134. ++p;
  135. if (*p == '"')
  136. {
  137. ++p;
  138. q=strchr(p, '"');
  139. if (q) *q=0;
  140. }
  141. if (strcmp(buf, "authmodulelist") == 0)
  142. {
  143. if (modlist)
  144. free(modlist);
  145. modlist=strdup(p);
  146. if (!modlist)
  147. {
  148. perror("malloc");
  149. fclose(fp);
  150. return (-1);
  151. }
  152. continue;
  153. }
  154. if (strcmp(buf, "daemons") == 0)
  155. {
  156. daemons=atoi(p);
  157. continue;
  158. }
  159. }
  160. fclose(fp);
  162. if (daemons <= 0)
  163. daemons=1;
  164. syslog(LOG_INFO, "authdaemon: modules="%s", daemons=%un",
  165. modlist ? modlist:AUTHDAEMONMODULELIST,
  166. daemons);
  167. ndaemons=daemons;
  168. if (authmodulelist) free(authmodulelist);
  169. authmodulelist=modlist;
  170. return (0);
  171. }
  174. static char buf[BUFSIZ];
  175. static char *readptr;
  176. static int readleft;
  177. static char *writeptr;
  178. static int writeleft;
  180. static int getauthc(int fd)
  181. {
  182. fd_set fds;
  183. struct timeval tv;
  185. if (readleft--)
  186. return ( (int)(unsigned char)*readptr++ );
  188. readleft=0;
  189. FD_ZERO(&fds);
  190. FD_SET(fd, &fds);
  191. tv.tv_sec=10;
  192. tv.tv_usec=0;
  193. if (select(fd+1, &fds, 0, 0, &tv) <= 0 ||
  194. !FD_ISSET(fd, &fds))
  195. return (EOF);
  196. readleft=read(fd, buf, sizeof(buf));
  197. readptr=buf;
  198. if (readleft <= 0)
  199. {
  200. readleft=0;
  201. return (EOF);
  202. }
  203. --readleft;
  204. return ( (int)(unsigned char)*readptr++ );
  205. }
  207. static int writeauth(int fd, const char *p, unsigned pl)
  208. {
  209. fd_set fds;
  210. struct timeval tv;
  212. while (pl)
  213. {
  214. int n;
  216. FD_ZERO(&fds);
  217. FD_SET(fd, &fds);
  218. tv.tv_sec=10;
  219. tv.tv_usec=0;
  220. if (select(fd+1, 0, &fds, 0, &tv) <= 0 ||
  221. !FD_ISSET(fd, &fds))
  222. return (-1);
  223. n=write(fd, p, pl);
  224. if (n <= 0) return (-1);
  225. p += n;
  226. pl -= n;
  227. }
  228. return (0);
  229. }
  231. static int writeauthflush(int fd)
  232. {
  233. if (writeptr > buf)
  234. {
  235. if (writeauth(fd, buf, writeptr - buf))
  236. return (-1);
  237. }
  238. writeptr=buf;
  239. writeleft=sizeof(buf);
  240. return (0);
  241. }
  243. static int writeauthbuf(int fd, const char *p, unsigned pl)
  244. {
  245. unsigned n;
  247. while (pl)
  248. {
  249. if (pl < writeleft)
  250. {
  251. memcpy(writeptr, p, pl);
  252. writeptr += pl;
  253. writeleft -= pl;
  254. return (0);
  255. }
  257. if (writeauthflush(fd)) return (-1);
  259. n=pl;
  260. if (n > writeleft) n=writeleft;
  261. memcpy(writeptr, p, n);
  262. p += n;
  263. writeptr += n;
  264. writeleft -= n;
  265. pl -= n;
  266. }
  267. return (0);
  268. }
  270. static int writeenvval(int fd, const char *env, const char *val)
  271. {
  272. if (writeauthbuf(fd, env, strlen(env)) ||
  273. writeauthbuf(fd, "=", 1) ||
  274. writeauthbuf(fd, val, strlen(val)) ||
  275. writeauthbuf(fd, "n", 1))
  276. return (-1);
  277. return (0);
  278. }
  280. static int printauth(struct authinfo *authinfo, void *vp)
  281. {
  282. int fd= *(int *)vp;
  283. char buf2[NUMBUFSIZE];
  285. writeptr=buf;
  286. writeleft=sizeof(buf);
  288. if (authinfo->sysusername)
  289. if (writeenvval(fd, "USERNAME", authinfo->sysusername))
  290. return (1);
  291. if (authinfo->sysuserid)
  292. if (writeenvval(fd, "UID", str_uid_t(*authinfo->sysuserid,
  293. buf2)))
  294. return (1);
  295. if (writeenvval(fd, "GID", str_uid_t(authinfo->sysgroupid, buf2)))
  296. return (1);
  298. if (writeenvval(fd, "HOME", authinfo->homedir))
  299. return (1);
  300. if (authinfo->address)
  301. if (writeenvval(fd, "ADDRESS", authinfo->address))
  302. return (1);
  303. if (authinfo->fullname)
  304. if (writeenvval(fd, "NAME", authinfo->fullname))
  305. return (1);
  306. if (authinfo->maildir)
  307. if (writeenvval(fd, "MAILDIR", authinfo->maildir))
  308. return (1);
  309. if (authinfo->quota)
  310. if (writeenvval(fd, "QUOTA", authinfo->quota))
  311. return (1);
  312. if (authinfo->passwd)
  313. if (writeenvval(fd, "PASSWD", authinfo->passwd))
  314. return (1);
  315. if (authinfo->clearpasswd)
  316. if (writeenvval(fd, "PASSWD2", authinfo->clearpasswd))
  317. return (1);
  318. if (writeauthbuf(fd, ".n", 2) || writeauthflush(fd))
  319. return (1);
  320. return (0);
  321. }
  323. static void printauth_void(struct authinfo *authinfo, void *vp)
  324. {
  325. printauth(authinfo, vp);
  326. }
  328. static const char *authnextptr;
  329. static int authnexti;
  331. static void authbegin()
  332. {
  333. authnextptr=authmodulelist;
  334. authnexti=0;
  335. }
  337. static int authnext()
  338. {
  339. if (authmodulelist == 0)
  340. {
  341. if (authstaticlist[authnexti].auth_name == 0)
  342. return (-1);
  343. return (authnexti++);
  344. }
  346. for (;;)
  347. {
  348. int i;
  350. while (*authnextptr &&
  351. isspace((int)(unsigned char)*authnextptr))
  352. ++authnextptr;
  353. if (*authnextptr == 0) return (-1);
  354. for (i=0; authnextptr[i] &&
  355. !isspace((int)(unsigned char)authnextptr[i]); i++)
  356. ;
  358. for (authnexti=0; authstaticlist[authnexti].auth_name;
  359. authnexti++)
  360. if (strncmp(authstaticlist[authnexti].auth_name,
  361. authnextptr, i) == 0 &&
  362. authstaticlist[authnexti].auth_name[i] == 0)
  363. {
  364. authnextptr += i;
  365. return (authnexti);
  366. }
  367. authnextptr += i;
  368. }
  369. }
  371. static void pre(int fd, char *prebuf)
  372. {
  373. char *p=strchr(prebuf, ' ');
  374. char *service;
  375. int i;
  377. if (!p) return;
  378. *p++=0;
  379. while (*p == ' ') ++p;
  380. service=p;
  381. p=strchr(p, ' ');
  382. if (!p) return;
  383.         *p++=0;
  384.         while (*p == ' ')     ++p;
  386. for (authbegin(); (i=authnext()) >= 0; )
  387. {
  388. int rc;
  390. if (strcmp(prebuf, ".") && strcmp(prebuf,
  391. authstaticlist[i].auth_name))
  392. continue;
  394. rc=(*authstaticlist[i].auth_prefunc)(p, service,
  395.                         &printauth, &fd);
  396. if (rc >= 0) return;
  397. }
  398. writeauth(fd, "FAILn", 5);
  399. }
  401. static void auth(int fd, char *p)
  402. {
  403. char *service;
  404. char *authtype;
  405. int i;
  406. char *pp;
  408. service=p;
  409. if ((p=strchr(p, 'n')) == 0) return;
  410. *p++=0;
  411. authtype=p;
  412. if ((p=strchr(p, 'n')) == 0) return;
  413. *p++=0;
  415. pp=malloc(strlen(p)+1);
  416. if (!pp)
  417. {
  418. syslog(LOG_CRIT, "authdaemon: malloc() failed: %m");
  419. return;
  420. }
  422. for (authbegin(); (i=authnext()) >= 0; )
  423. {
  424. char *q=(*authstaticlist[i].auth_func)(service, authtype,
  425. strcpy(pp, p), 1, &printauth_void, &fd);
  426. if (q)
  427. {
  428. free(q);
  429. free(pp);
  430. return;
  431. }
  432. if (errno != EPERM)
  433. {
  434. free(pp);
  435. return; /* Temporary error */
  436. }
  437. }
  438. writeauth(fd, "FAILn", 5);
  439. free(pp);
  440. }
  442. static void doauth(int fd)
  443. {
  444. char buf[BUFSIZ];
  445. int i, ch;
  446. char *p;
  448. readleft=0;
  449. for (i=0; (ch=getauthc(fd)) != 'n'; i++)
  450. {
  451. if (ch < 0 || i >= sizeof(buf)-2)
  452. return;
  453. buf[i]=ch;
  454. }
  455. buf[i]=0;
  457. for (p=buf; *p; p++)
  458. {
  459. if (*p == ' ')
  460. {
  461. *p++=0;
  462. while (*p == ' ') ++p;
  463. break;
  464. }
  465. }
  467. if (strcmp(buf, "PRE") == 0)
  468. {
  469. pre(fd, p);
  470. return;
  471. }
  473. if (strcmp(buf, "AUTH") == 0)
  474. {
  475. int j;
  477. i=atoi(p);
  478. if (i < 0 || i >= sizeof(buf)) return;
  479. for (j=0; j<i; j++)
  480. {
  481. ch=getauthc(fd);
  482. if (ch < 0) return;
  483. buf[j]=ch;
  484. }
  485. buf[j]=0;
  486. auth(fd, buf);
  487. }
  488. }
  490. static int sighup_pipe= -1;
  492. static RETSIGTYPE sighup(int n)
  493. {
  494. if (sighup_pipe >= 0)
  495. {
  496. close(sighup_pipe);
  497. sighup_pipe= -1;
  498. }
  499. signal(SIGHUP, sighup);
  500. #if RETSIGTYPE != void
  501. return (1);
  502. #endif
  503. }
  505. static int sigterm_received=0;
  507. static RETSIGTYPE sigterm(int n)
  508. {
  509. sigterm_received=1;
  510. if (sighup_pipe >= 0)
  511. {
  512. close(sighup_pipe);
  513. sighup_pipe= -1;
  514. }
  515. else
  516. {
  517. kill(0, SIGTERM);
  518. _exit(0);
  519. }
  521. #if RETSIGTYPE != void
  522. return (0);
  523. #endif
  524. }
  526. static int startchildren(int *pipefd)
  527. {
  528. unsigned i;
  529. pid_t p;
  531. if (ndaemons <= 1)
  532. {
  533. return (0); /* No need for kids */
  534. }
  536. for (i=0; i<ndaemons; i++)
  537. {
  538. p=fork();
  539. if (p == -1)
  540. {
  541. syslog(LOG_CRIT, "authdaemon: fork() failed: %m");
  542. if (i == 0)
  543. ndaemons=1; /* Assume 1 daemon */
  544. return (0);
  545. }
  546. if (p == 0)
  547. {
  548. sighup_pipe= -1;
  549. close(pipefd[1]);
  550. signal(SIGHUP, SIG_DFL);
  551. signal(SIGTERM, SIG_DFL);
  552. return (1);
  553. }
  554. }
  555. return (0);
  556. }
  558. static int killchildren(int *pipefd)
  559. {
  560. int waitstat;
  562. while (wait(&waitstat) >= 0 || errno != ECHILD)
  563. ;
  565. if (pipe(pipefd))
  566. {
  567. syslog(LOG_CRIT, "authdaemon: pipe() failed: %m");
  568. return (-1);
  569. }
  571. return (0);
  572. }
  574. int start()
  575. {
  576. int s;
  577. int lockfd;
  578. int fd;
  579. int pipefd[2];
  580. int do_child;
  582. if ((lockfd=ll_daemon_start(AUTHDAEMONLOCK)) < 0)
  583. return (1);
  585. if (pipe(pipefd))
  586. {
  587. perror("pipe");
  588. return (1);
  589. }
  591. if (readconfig())
  592. {
  593. close(pipefd[0]);
  594. close(pipefd[1]);
  595. return (1);
  596. }
  598. s=mksocket();
  599. if (s < 0)
  600. {
  601. perror(AUTHDAEMONSOCK);
  602. close(pipefd[0]);
  603. close(pipefd[1]);
  604. return (1);
  605. }
  607. signal(SIGPIPE, SIG_IGN);
  608. signal(SIGHUP, sighup);
  609. signal(SIGTERM, sigterm);
  611. ll_daemon_started(AUTHDAEMONPID, lockfd);
  613. sighup_pipe= pipefd[1];
  615. do_child=startchildren(pipefd);
  617. for (;;)
  618. {
  619. struct sockaddr saddr;
  620. int saddr_len;
  621. fd_set fds;
  623. FD_ZERO(&fds);
  624. FD_SET(pipefd[0], &fds);
  626. if (do_child || ndaemons == 1)
  627. FD_SET(s, &fds);
  629. if (select( (s > pipefd[0] ? s:pipefd[0])+1,
  630. &fds, 0, 0, 0) <= 0)
  631. continue;
  632. if (FD_ISSET(pipefd[0], &fds))
  633. {
  634. close(pipefd[0]);
  635. if (do_child)
  636. return (0); /* Parent died */
  637. readconfig();
  638. while (killchildren(pipefd))
  639. sleep(5);
  640. if (sigterm_received)
  641. return (0);
  642. sighup_pipe=pipefd[1];
  643. do_child=startchildren(pipefd);
  644. continue;
  645. }
  647. if (!FD_ISSET(s, &fds))
  648. continue;
  650. saddr_len=sizeof(saddr);
  651. if ((fd=accept(s, &saddr, &saddr_len)) < 0)
  652. continue;
  653. if (fcntl(fd, F_SETFL, 0) < 0)
  654. {
  655. syslog(LOG_CRIT, "authdaemon: fcntl() failed: %m");
  656. }
  657. else
  658. doauth(fd);
  659. close(fd);
  660. }
  661. }
  663. int main(int argc, char **argv)
  664. {
  665. if (argc > 1)
  666. {
  667. if (strcmp(argv[1], "start") == 0)
  668. {
  669. exit(start());
  670. }
  672. if (strcmp(argv[1], "stop") == 0)
  673. {
  674. exit(ll_daemon_stop(AUTHDAEMONLOCK, AUTHDAEMONPID));
  675. }
  677. if (strcmp(argv[1], "restart") == 0)
  678. {
  679. exit(ll_daemon_restart(AUTHDAEMONLOCK, AUTHDAEMONPID));
  680. }
  681. }
  683. fprintf(stderr, "Usage: %s start|stop|restartn", argv[0]);
  684. exit (1);
  685. return (0);
  686. }