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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 网络编程 > 查看源码
pop_pass.c
资源名称：qpopper2.53.tar.Z　[点击查看]
上传用户：dayuan858
上传日期：2007-01-04
资源大小：194k
文件大小：16k
源码类别：

网络编程

开发平台：

Unix_Linux

pop_pass.c：源码内容
  1. /*
  2.  * Copyright (c) 1989 Regents of the University of California.
  3.  * All rights reserved.  The Berkeley software License Agreement
  4.  * specifies the terms and conditions for redistribution.
  5.  */
  7. /*
  8.  * Copyright (c) 1997 by Qualcomm Incorporated.
  9.  */
  11. #include <config.h>
  12. #include <stdio.h>
  13. #include <sys/types.h>
  14. #include <string.h>
  15. #if HAVE_STRINGS_H
  16. # include <strings.h>
  17. #endif
  19. #include <pwd.h>
  20. #include "popper.h"
  22. #define SLEEP_SECONDS 10
  25. /* This error message is vague on purpose to help reduce help improve
  26.    security at the inconvience of administrators and users */
  28. char *pwerrmsg = "Password supplied for "%s" is incorrect.";
  31. #ifdef NONAUTHFILE
  32. checknonauthfile(user) 
  33.      char *user;
  34. {
  35.     char buf[MAXUSERNAMELEN+1];
  36.     FILE *fp;
  37.     char cool = 0;
  39.     if ((fp = fopen(NONAUTHFILE, "r")) != NULL) {
  40. while (fgets(buf, MAXUSERNAMELEN+1, fp)) {
  41.     buf[strlen(buf) -1] = '';
  42.     if (!strcmp(buf, user)) {
  43. fclose(fp);
  44. return(-1);
  45.     }
  46. }
  48. fclose(fp);
  49.     }
  50.     return(0);
  51. }
  52. #endif
  54. #ifdef AUTHFILE
  55. checkauthfile(user) 
  56.      char *user;
  57. {
  58.     char buf[MAXUSERNAMELEN+1];
  59.     FILE *fp;
  60.     char cool = 0;
  62.     if ((fp = fopen(AUTHFILE, "r")) != NULL) {
  63. while (fgets(buf, MAXUSERNAMELEN+1, fp)) {
  64.     buf[strlen(buf) -1] = '';
  65.     if (!strcmp(buf, user)) {
  66. fclose(fp);
  67. return(0);
  68.     }
  69. }
  71. fclose(fp);
  72.     }
  73.     return(-1);
  74. }
  75. #endif
  77. int auth_user_kerberos (p, pw)
  78. POP     *   p;
  79. struct passwd *pw;
  80. {
  81. #ifdef KERBEROS
  82.     char lrealm[REALM_SZ];
  83.     int status;
  84.     struct passwd *pwp;
  85.  
  86.     if ((status = krb_get_lrealm(lrealm,1)) == KFAILURE) {
  87.         pop_log(p, LOG_WARNING, "%s: (%s.%s@%s) %s", p->client, kdata.pname, 
  88. kdata.pinst, kdata.prealm, krb_err_txt[status]);
  89.         return(pop_msg(p,POP_FAILURE,
  90.             "Kerberos error:  "%s".", krb_err_txt[status]));
  91.     }
  93. # ifdef KUSEROK
  94.     if (kuserok(&kdata, p->user)) {
  95.         pop_log(p, LOG_WARNING, "%s: (%s.%s@%s): not in %s's ACL.",
  96.     p->client, kdata.pname, kdata.pinst, kdata.prealm, p->user);
  97. return(pop_msg(p,POP_FAILURE, "Not in %s's ACL.", p->user));
  98.     }
  99. # else
  100.     if (strcmp(kdata.prealm,lrealm))  {
  101.          pop_log(p, LOG_WARNING, "%s: (%s.%s@%s) realm not accepted.", 
  102.  p->client, kdata.pname, kdata.pinst, kdata.prealm);
  103.  return(pop_msg(p,POP_FAILURE,
  104.      "Kerberos realm "%s" not accepted.", kdata.prealm));
  105.     }
  107.     if (strcmp(kdata.pinst,"")) {
  108.         pop_log(p, LOG_WARNING, "%s: (%s.%s@%s) instance not accepted.", 
  109.  p->client, kdata.pname, kdata.pinst, kdata.prealm);
  110.         return(pop_msg(p,POP_FAILURE,
  111.       "Must use null Kerberos(tm) instance -  "%s.%s" not accepted.",
  112.       kdata.pname, kdata.pinst));
  113.     }
  114. # endif /* KUSEROK */
  115.     return(POP_SUCCESS);
  116. #else /* Kerberos not defined */
  117.     return(pop_log(p, LOG_WARNING,
  118. "Kerberos failure: The popper has not been compiled with -DKERBEROS"));
  119. #endif /* KERBEROS */
  120. }
  123. #ifdef AUTH_SPECIAL
  124.     char *crypt();
  126. #if defined(SUNOS4) && !defined(ISC)
  128. #include <sys/label.h>
  129. #include <sys/audit.h>
  130. #include <pwdadj.h>
  132. static int
  133. auth_user(p, pw)
  134. POP     *   p;
  135. struct passwd *pw;
  136. {
  137.     struct passwd_adjunct *pwadj;
  139.     /*  Look for the user in the shadow password file */
  140.     if ((pwadj = getpwanam(p->user)) == NULL) {
  141. sleep(SLEEP_SECONDS);
  142. return (pop_msg(p,POP_FAILURE,
  143. "(shadow) Password supplied for "%s" is empty.",p->user));
  144.     } else {
  145.         pw->pw_passwd = (char *)strdup(pwadj->pwa_passwd);
  146.     }
  148.     /*  We don't accept connections from users with null passwords */
  149.     /*  Compare the supplied password with the password file entry */
  150.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  151. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  152. sleep(SLEEP_SECONDS);
  153. return (pop_msg(p,POP_FAILURE,pwerrmsg, p->user));
  154.     }
  156.     return(POP_SUCCESS);
  157. }
  159. #endif /* SUNOS4 */
  161. #if defined(SOLARIS2) || defined(AUX) || defined(UXPDS)
  163. #include <shadow.h>
  165. static int
  166. auth_user(p, pw)
  167. POP     *   p;
  168. struct passwd *pw;
  169. {
  170.     register struct spwd * pwd;
  171.     long today;
  173.     /*  Look for the user in the shadow password file */
  174.     if ((pwd = getspnam(p->user)) == NULL) {
  175.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  176.     sleep(SLEEP_SECONDS);
  177.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  178. }
  179.     } else {
  180. today = (long)time((time_t *)NULL)/24/60/60;
  182. /* Check for expiration date */
  183. if (pwd->sp_expire > 0 && today > pwd->sp_expire) {
  184.     sleep(SLEEP_SECONDS);
  185.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  186. }
  188. /* Check if password is valid */
  189. if (pwd->sp_max > 0 && today > pwd->sp_lstchg+pwd->sp_max) {
  190.     sleep(SLEEP_SECONDS);
  191.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  192. }
  194. pw->pw_passwd = (char *)strdup(pwd->sp_pwdp);
  195. endspent();
  196.     }
  198.     /*  We don't accept connections from users with null passwords */
  199.     /*  Compare the supplied password with the password file entry */
  200.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  201. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  202. sleep(SLEEP_SECONDS);
  203. return (pop_msg(p, POP_FAILURE, pwerrmsg, p->user));
  204.     }
  206.     return(POP_SUCCESS);
  207. }
  209. #endif /* SOLARIS2 || AUX */
  211. #if defined(PTX) || defined(ISC)
  213. #include <shadow.h>
  215. static int
  216. auth_user(p, pw)
  217. POP     *   p;
  218. struct passwd *pw;
  219. {
  220.     register struct spwd * pwd;
  221.     long today;
  223.     /*  Look for the user in the shadow password file */
  224.     if ((pwd = getspnam(p->user)) == NULL) {
  225.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  226.     sleep(SLEEP_SECONDS);
  227.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  228. }
  229.     } else {
  230. pw->pw_passwd = (char *)strdup(pwd->sp_pwdp);
  231.     }
  233.     /*  We don't accept connections from users with null passwords */
  234.     /*  Compare the supplied password with the password file entry */
  235.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  236. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  237. sleep(SLEEP_SECONDS);
  238. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  239.     }
  241.     return(POP_SUCCESS);
  242. }
  244. #endif /* PTX */
  246. #if defined(POPSCO) || defined(HPUX10)
  248. #ifdef POPSCO
  249. # include <sys/security.h>
  250. # include <sys/audit.h>
  251. #else
  252. # include <hpsecurity.h>
  253. #endif
  255. #include <prot.h>
  256. #define PASSWD(p) p->ufld.fd_encrypt
  258. static int
  259. auth_user(p, pw)
  260. POP     *   p;
  261. struct passwd *pw;
  262. {
  263.     register struct pr_passwd *pr;
  265.     if ((pr = getprpwnam(p->user)) == NULL) {
  266.         if (!strcmp(pw->pw_passwd, "x")) {
  267.     sleep(SLEEP_SECONDS);
  268.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  269. }
  271. /*  We don't accept connections from users with null passwords */
  272. if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  273.              (strcmp(bigcrypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd) &&
  274.       strcmp(crypt (p->pop_parm[1], pw->pw_passwd), pw->pw_passwd))) {
  275.     sleep(SLEEP_SECONDS);
  276.     return(pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  277. }
  278.     } else {
  279. /*  We don't accept connections from users with null passwords */
  280. /*  Compare the supplied password with the password file entry */
  281. if ((PASSWD(pr) == NULL) || (*PASSWD(pr) == '')) {
  282.     sleep(SLEEP_SECONDS);
  283.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  284. }
  286. if (strcmp(bigcrypt(p->pop_parm[1], PASSWD(pr)), PASSWD(pr)) &&
  287.     strcmp(crypt(p->pop_parm[1], PASSWD(pr)), PASSWD(pr))) {
  288.     sleep(SLEEP_SECONDS);
  289.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  290. }
  291.     }
  293.     return(POP_SUCCESS);
  294. }
  296. #endif /* POPSCO || HPUX10 */
  298. #ifdef ULTRIX
  300. #include <auth.h>
  302. static int
  303. auth_user(p, pw)
  304. struct passwd  *   pw;
  305. POP     *   p;
  306. {
  307.     AUTHORIZATION *auth, *getauthuid();
  309.     if ((auth = getauthuid(pw->pw_uid)) == NULL) {
  310.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  311.     sleep(SLEEP_SECONDS);
  312.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  313. }
  314.     } else {
  315. pw->pw_passwd = (char *)strdup(auth->a_password);
  316.     }
  318.     /*  We don't accept connections from users with null passwords */
  319.     /*  Compare the supplied password with the password file entry */
  320.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '')) {
  321. sleep(SLEEP_SECONDS);
  322. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  323.     }
  325.     if (strcmp(crypt16(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd) &&
  326. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  327. sleep(SLEEP_SECONDS);
  328. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  329.     }
  331.     return(POP_SUCCESS);
  332. }
  334. #endif /* ULTRIX */
  336. #ifdef OSF1
  337. #include <sys/types.h>
  338. #include <sys/security.h>
  339. #include <prot.h>
  340. #define   PASSWD(p)   (p->ufld.fd_encrypt)
  341. static int
  342. auth_user(p, pw)
  343. POP     *   p;
  344. struct passwd *pw;
  345. {
  346.     register struct pr_passwd *pr;
  348.     if ((pr = getprpwnam(p->user)) == NULL) {
  349.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  350.     sleep(SLEEP_SECONDS);
  351.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  352. }
  353.     } else {
  354. pw->pw_passwd = (char *)strdup(PASSWD(pr));
  355.     }
  357.     /*  We don't accept connections from users with null passwords */
  358.     /*  Compare the supplied password with the password file entry */
  359.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '')) {
  360. sleep(SLEEP_SECONDS);
  361. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  362.     }
  364.     if (strcmp(bigcrypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd) &&
  365. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  366. sleep(SLEEP_SECONDS);
  367. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  368.     }
  370.     return(POP_SUCCESS);
  371. }
  373. #endif        /* OSF1 */
  375. #ifdef UNIXWARE
  377. #include <shadow.h>
  379. static int
  380. auth_user(p, pw)
  381. struct passwd  *   pw;
  382. POP     *   p;
  383. {
  384.     register struct spwd * pwd;
  385.     long today;
  387.     /*  Look for the user in the shadow password file */
  388.     if ((pwd = getspnam(p->user)) == NULL) {
  389.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  390.     sleep(SLEEP_SECONDS);
  391.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  392. }
  393.     } else {
  394. today = (long)time((time_t *)NULL)/24/60/60;
  396. /* Check for expiration date */
  397. if (pwd->sp_expire > 0 && today > pwd->sp_expire) {
  398.     sleep(SLEEP_SECONDS);
  399.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  400. }
  402. /* Check if password is valid */
  403. if (pwd->sp_max > 0 && today > pwd->sp_lstchg+pwd->sp_max) {
  404.     sleep(SLEEP_SECONDS);
  405.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  406. }
  408. pw->pw_passwd = (char *)strdup(pwd->sp_pwdp);
  409. endspent();
  410.     }
  412.     /*  We don't accept connections from users with null passwords */
  413.     /*  Compare the supplied password with the password file entry */
  414.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  415. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  416. sleep(SLEEP_SECONDS);
  417. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  418.     }
  420.     return(POP_SUCCESS);
  421. }
  423. #endif /* UNIXWARE */
  425. #ifdef LINUX
  426. #ifdef HAVE_SHADOW_H
  427. #include <shadow.h>
  428. #endif
  429.  
  430. static int
  431. auth_user(p, pw)
  432. POP     *   p;
  433. struct passwd *pw;
  434. {
  435.     register struct spwd * pwd;
  436.     long today;
  438.     /*  Look for the user in the shadow password file */
  439.     if ((pwd = getspnam(p->user)) == NULL) {
  440.         if (!strcmp(pw->pw_passwd, "x")) { /* This my be a YP entry */
  441.     sleep(SLEEP_SECONDS);
  442.     return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  443. }
  444.     } else {
  445. today = (long)time((time_t *)NULL)/24/60/60;
  447. /* Check for expiration date */
  448. if (pwd->sp_expire > 0 && today > pwd->sp_expire) {
  449.     sleep(SLEEP_SECONDS);
  450.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  451. }
  453. /* Check if password is valid */
  454. if (pwd->sp_max > 0 && today > pwd->sp_lstchg+pwd->sp_max) {
  455.     sleep(SLEEP_SECONDS);
  456.     return (pop_msg(p,POP_FAILURE,""%s": account expired.",p->user));
  457. }
  459. pw->pw_passwd = (char *)strdup(pwd->sp_pwdp);
  460. endspent();
  461.     }
  463.     /*  We don't accept connections from users with null passwords */
  464.     /*  Compare the supplied password with the password file entry */
  465.     /*  pw_encrypt() ??                                            */
  466.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') || 
  467.     (strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)
  468. #ifdef HAVE_PW_ENCRYPT
  469.      && strcmp(pw_encrypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)
  470. #endif
  471.      )){
  472. sleep(SLEEP_SECONDS);
  473. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  474.     }
  476.     return(POP_SUCCESS);
  477. }
  479. #endif  /* LINUX */
  481. #else /* NOT AUTH_SPECIAL */
  483. char *crypt();
  485. static int
  486. auth_user(p, pw)
  487. POP     *   p;
  488. struct passwd  *   pw;
  489. {
  490.     /*  We don't accept connections from users with null passwords */
  491.     /*  Compare the supplied password with the password file entry */
  493.     if ((pw->pw_passwd == NULL) || (*pw->pw_passwd == '') ||
  494. strcmp(crypt(p->pop_parm[1], pw->pw_passwd), pw->pw_passwd)) {
  495. sleep(SLEEP_SECONDS);
  496. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  497.     }
  499.     return(POP_SUCCESS);
  500. }
  502. #endif /* AUTH_SPECIAL */
  504. /* 
  505.  *  pass:   Obtain the user password from a POP client
  506.  */
  508. #ifdef SECURENISPLUS
  509. # include <rpc/rpc.h>
  510. # include <rpc/key_prot.h>
  511. #endif
  513. int pop_pass (p)
  514. POP     *   p;
  515. {
  516.     struct passwd pw, *pwp;
  517. #ifdef CHECK_SHELL
  518.     char *getusershell();
  519.     void endusershell();
  520.     char *shell;
  521.     char *cp;
  522.     int shellvalid;
  523. #endif
  525. #ifdef SECURENISPLUS
  526.     UID_T uid_save;
  527.     char net_name[MAXNETNAMELEN],
  528.  secretkey[HEXKEYBYTES + 1];
  530.     *secretkey = '';
  531. #endif
  533. #ifdef NONAUTHFILE
  534.     /* Is the user not authorized to use POP? */
  535.     if (checknonauthfile(p->user) != 0) {
  536. sleep(SLEEP_SECONDS);
  537. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  538.     }
  539. #endif
  541. #ifdef AUTHFILE
  542.     /* Is the user authorized to use POP? */
  543.     if (checkauthfile(p->user) != 0) {
  544. sleep(SLEEP_SECONDS);
  545. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  546.     }
  547. #endif
  549.     /*  Look for the user in the password file */
  550.     if ((pwp = getpwnam(p->user)) == NULL) {
  551. sleep(SLEEP_SECONDS);
  552. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  553.     }
  555.     pw = *pwp;
  557. #ifdef SECURENISPLUS
  558.     /*  we must do this keyserv stuff (as well as auth_user()!) as the user */
  559.     uid_save = geteuid();
  560.     seteuid(pw.pw_uid);
  562.     /*  see if DES keys are already known to the keyserv(1m) */
  563.     if (! key_secretkey_is_set()) {
  564. /*  keys are not known, so we must get the DES keys
  565.     and register with the keyserv(1m) */
  567. getnetname(net_name);
  569. if (getpublickey(net_name, secretkey)) {
  570.     if (strlen(p->pop_parm[1]) > 8) (p->pop_parm[1])[8] = '';
  572.     if (! getsecretkey(net_name, secretkey, p->pop_parm[1]) ||
  573. *secretkey == '') {
  574. sleep(SLEEP_SECONDS);
  575. return (pop_msg(p,POP_FAILURE, pwerrmsg, p->user));
  576.     }
  578.     key_setsecret(secretkey);
  579.     memset(secretkey, '', sizeof(secretkey));
  580. } else {
  581.     /* if there are no keys defined, we assume that password entry
  582.        either resides in /etc/shadow or "root" has access to the
  583.        corresponding NIS+ entry */
  584.     seteuid(0);
  585. }
  586.     }
  587. #endif
  589. #ifdef BLOCK_UID
  590.     if (pw.pw_uid <= BLOCK_UID)
  591. return (pop_msg(p,POP_FAILURE,
  592.     "Access is blocked for UIDs below %d", BLOCK_UID));
  593. #endif
  595. #ifdef CHECK_SHELL
  596.     /*  Disallow anyone who does not have a standard shell as returned by
  597.      *  getusershell(), unless the sys admin has included the wildcard
  598.      *  shell in /etc/shells.  (default wildcard - /POPPER/ANY/SHELL)
  599.      */
  600.     if ((shell = pw.pw_shell) == NULL || *shell == 0)
  601. /* You can default the shell, but I don't think it's a good idea */
  602. /* shell = "/usr/bin/sh"; */
  603. return(pop_msg(p, POP_FAILURE, "No user shell defined"));
  604.     
  605.     for (shellvalid = 0; !shellvalid && ((cp = getusershell()) != NULL);)
  606. if (!strcmp(cp, WILDCARD_SHELL) || !strcmp(cp, shell))
  607.      shellvalid = 1;
  608.     endusershell();
  610.     if (!shellvalid)
  611. return(pop_msg(p, POP_FAILURE, ""%s": shell not found.", p->user));
  612. #endif
  614.     if ((p->kerberos ? auth_user_kerberos(p, pw) : auth_user(p, pwp))
  615. != POP_SUCCESS) {
  616.     pop_log(p,POP_PRIORITY,"Failed attempted login to %s from host %s",
  617.     p->user, p->client);
  618. return(POP_FAILURE);
  619.     }
  621. #ifdef SECURENISPLUS
  622.     seteuid(uid_save);
  623. #endif
  625.     /*  Make a temporary copy of the user's maildrop */
  626.     /*    and set the group and user id */
  627.     /*    and get information about the maildrop */
  628.     if (pop_dropcopy(p, &pw) != POP_SUCCESS) return (POP_FAILURE);
  630.     /*  Initialize the last-message-accessed number */
  631.     p->last_msg = 0;
  633.     /*  Authorization completed successfully */
  634.     return (pop_msg (p,POP_SUCCESS,
  635.         "%s has %d message%s (%d octets).",
  636.             p->user,p->msg_count, p->msg_count == 1 ? "" : "s", p->drop_size));
  637. }