← Back to branch summary

~ubuntu-branches/ubuntu/trusty/proftpd-dfsg/trusty

« back to all changes in this revision

Viewing changes to modules/mod_delay.c

  • Committer: Bazaar Package Importer
  • Author(s): Francesco Paolo Lovergine
  • Date: 2011-10-06 12:57:29 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20111006125729-wiq6d3yzf2ensafj
Tags: 1.3.4~rc3-1
* New upstream pre-release.
* Refreshed all patches.
* Changed patch xferstats.holger-preiss to fix a few warnings and use
  Getopt::Std instead of the old getopts.pl which will be removed soon or
  later in perl5. Thanks lintian.
* Policy bumped to 3.9.2.

Show diffs side-by-side

added added

removed removed

Lines of Context:
modules/mod_delay.c
16
16
 *
17
17
 * You should have received a copy of the GNU General Public License
18
18
 * along with this program; if not, write to the Free Software
19
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
 
19
 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
20
20
 *
21
21
 * As a special exemption, TJ Saunders and other respective copyright holders
22
22
 * give permission to link this program with OpenSSL, and distribute the
26
26
 * This is mod_delay, contrib software for proftpd 1.2.10 and above.
27
27
 * For more information contact TJ Saunders <tj@castaglia.org>.
28
28
 *
29
 
 * $Id: mod_delay.c,v 1.55 2011/03/22 18:44:16 castaglia Exp $
 
29
 * $Id: mod_delay.c,v 1.60 2011/06/05 23:18:23 castaglia Exp $
30
30
 */
31
31
 
32
32
#include "conf.h"
33
33
#include "privs.h"
34
34
 
35
 
#define MOD_DELAY_VERSION               "mod_delay/0.6"
 
35
#define MOD_DELAY_VERSION               "mod_delay/0.7"
36
36
 
37
37
/* Make sure the version of proftpd is as necessary. */
38
38
#if PROFTPD_VERSION_NUMBER < 0x0001021001
290
290
    sigaddset(&mask_sigset, SIGUSR1);
291
291
    sigaddset(&mask_sigset, SIGINT);
292
292
    sigaddset(&mask_sigset, SIGQUIT);
293
 
    sigaddset(&mask_sigset, SIGALRM);
294
293
#ifdef SIGIO
295
294
    sigaddset(&mask_sigset, SIGIO);
296
295
#endif
301
300
 
302
301
    sigprocmask(SIG_BLOCK, &mask_sigset, NULL);
303
302
 
304
 
  } else
 
303
  } else {
305
304
    sigprocmask(SIG_UNBLOCK, &mask_sigset, NULL);
 
305
  }
306
306
}
307
307
 
308
308
static void delay_signals_block(void) {
316
316
static void delay_delay(long interval) {
317
317
  struct timeval tv;
318
318
  long rand_usec;
 
319
  int res, xerrno;
319
320
 
320
321
  /* Add an additional delay of a random number of usecs, with a 
321
322
   * maximum of half of the given interval.
332
333
    (long int) ((tv.tv_sec * 1000000) + tv.tv_usec));
333
334
 
334
335
  delay_signals_block();
335
 
  (void) select(0, NULL, NULL, NULL, &tv);
 
336
  res = select(0, NULL, NULL, NULL, &tv);
 
337
  xerrno = errno;
336
338
  delay_signals_unblock();
 
339
 
 
340
  if (res < 0 &&
 
341
      xerrno == EINTR) {
 
342
 
 
343
    /* If we were interrupted, handle the interrupting signal. */
 
344
    pr_signals_handle();
 
345
  }
 
346
}
 
347
 
 
348
/* There are two rows (USER and PASS) for each server ID (SID).
 
349
 *
 
350
 * The main server has a SID of 1.  Thus to access the USER row for SID 1,
 
351
 * the row index is 0; the PASS row for SID 1 has a row index of 1.
 
352
 *
 
353
 * The general formula for the USER row of a given SID is:
 
354
 *
 
355
 *   r = (sid * 2) - 2;
 
356
 *
 
357
 * and thus for accessing the PASS row, the formula is:
 
358
 *
 
359
 *   r = (sid * 2) - 1;
 
360
 */
 
361
static unsigned int delay_get_user_rownum(unsigned int sid) {
 
362
  unsigned int r;
 
363
 
 
364
  r = (sid * 2) - 2;
 
365
  return r;
 
366
}
 
367
 
 
368
static unsigned int delay_get_pass_rownum(unsigned int sid) {
 
369
  unsigned int r;
 
370
 
 
371
  r = (sid * 2) - 1;
 
372
  return r;
337
373
}
338
374
 
339
375
static void delay_table_add_interval(unsigned int rownum, const char *protocol,
530
566
    struct delay_rec *row;
531
567
 
532
568
    for (s = (server_rec *) server_list->xas_list; s; s = s->next) {
533
 
      unsigned int i = s->sid - 1;
 
569
      unsigned int r;
534
570
 
535
571
      /* Row for USER values */
536
 
      row = &((struct delay_rec *) delay_tab.dt_data)[i];
 
572
      r = delay_get_user_rownum(s->sid);
 
573
      row = &((struct delay_rec *) delay_tab.dt_data)[r];
537
574
      if (strcmp(pr_netaddr_get_ipstr(s->addr), row->d_addr) != 0) {
538
575
        reset_table = TRUE;
539
576
        break;
545
582
      }
546
583
 
547
584
      /* Row for PASS values */
548
 
      row = &((struct delay_rec *) delay_tab.dt_data)[i + 1];
 
585
      r = delay_get_pass_rownum(s->sid);
 
586
      row = &((struct delay_rec *) delay_tab.dt_data)[r];
549
587
      if (strcmp(pr_netaddr_get_ipstr(s->addr), row->d_addr) != 0) {
550
588
        reset_table = TRUE;
551
589
        break;
733
771
  server_rec *s;
734
772
 
735
773
  for (s = (server_rec *) server_list->xas_list; s; s = s->next) {
736
 
    unsigned int i = s->sid - 1;
 
774
    unsigned int r;
737
775
    struct delay_rec *row;
738
776
    struct delay_vals_rec *dv;
739
777
 
740
778
    /* Row for USER values */
741
 
    row = &((struct delay_rec *) delay_tab.dt_data)[i];
 
779
    r = delay_get_user_rownum(s->sid);
 
780
    row = &((struct delay_rec *) delay_tab.dt_data)[r];
742
781
    row->d_sid = s->sid;
743
782
    sstrncpy(row->d_addr, pr_netaddr_get_ipstr(s->addr), sizeof(row->d_addr));
744
783
    row->d_port = s->ServerPort;
764
803
    memset(dv->dv_vals, -1, sizeof(dv->dv_vals));
765
804
 
766
805
    /* Row for PASS values */
767
 
    row = &((struct delay_rec *) delay_tab.dt_data)[i + 1];
 
806
    r = delay_get_pass_rownum(s->sid);
 
807
    row = &((struct delay_rec *) delay_tab.dt_data)[r];
768
808
    row->d_sid = s->sid;
769
809
    sstrncpy(row->d_addr, pr_netaddr_get_ipstr(s->addr), sizeof(row->d_addr));
770
810
    row->d_port = s->ServerPort;
909
949
  }
910
950
  PRIVS_RELINQUISH
911
951
 
912
 
  if (!fh) {
 
952
  if (fh == NULL) {
913
953
    pr_ctrls_add_response(ctrl,
914
954
      "warning: unable to open DelayTable '%s': %s", delay_tab.dt_path,
915
955
      strerror(xerrno));
916
 
    xerrno = errno;
 
956
    errno = xerrno;
917
957
    return -1;
918
958
  }
919
959
 
941
981
  tmp_pool = make_sub_pool(delay_pool);
942
982
 
943
983
  for (s = (server_rec *) server_list->xas_list; s; s = s->next) {
944
 
    unsigned int r = s->sid - 1;
 
984
    unsigned int r;
945
985
    register unsigned int i;
946
986
    struct delay_rec *row;
947
 
 
 
987
 
948
988
    /* Row for USER values */
 
989
    r = delay_get_user_rownum(s->sid);
949
990
    row = &((struct delay_rec *) delay_tab.dt_data)[r];
950
991
    pr_ctrls_add_response(ctrl, "Address %s#%u: USER values (usecs):",
951
992
      row->d_addr, row->d_port);
990
1031
    pr_ctrls_add_response(ctrl, "%s", "");
991
1032
 
992
1033
    /* Row for PASS values */
993
 
    row = &((struct delay_rec *) delay_tab.dt_data)[r + 1];
 
1034
    r = delay_get_pass_rownum(s->sid);
 
1035
    row = &((struct delay_rec *) delay_tab.dt_data)[r];
994
1036
    pr_ctrls_add_response(ctrl, "Address %s#%u: PASS values (usecs):",
995
1037
      row->d_addr, row->d_port);
996
1038
 
1027
1069
      if (strlen(vals) > 0)
1028
1070
        pr_ctrls_add_response(ctrl, "    %s", vals);
1029
1071
    }
 
1072
 
 
1073
    pr_ctrls_add_response(ctrl, "%s", "");
1030
1074
  }
1031
 
  pr_ctrls_add_response(ctrl, "%s", "");
1032
1075
 
1033
1076
  if (delay_table_unload(TRUE) < 0) {
1034
1077
    pr_ctrls_add_response(ctrl,
1225
1268
      *authenticated == TRUE) {
1226
1269
    return PR_DECLINED(cmd);
1227
1270
  }
1228
 
 
1229
 
  /* We use sid-1, since the sid is a server number, and the locking
1230
 
   * routines want a row index.  However, PASS rows are always after
1231
 
   * USER rows, so we need to add 1 to the row number, leaving us
1232
 
   * with just the sid.
1233
 
   */
1234
 
  rownum = main_server->sid;
 
1271
 
 
1272
  rownum = delay_get_pass_rownum(main_server->sid);
1235
1273
 
1236
1274
  /* Prepare for manipulating the table. */
1237
1275
  if (delay_table_load(FALSE) < 0) {
1339
1377
    return PR_DECLINED(cmd);
1340
1378
  }
1341
1379
 
1342
 
  /* We use sid-1, since the sid is a server number, and the locking
1343
 
   * routines want a row index.
1344
 
   */
1345
 
  rownum = main_server->sid - 1;
 
1380
  rownum = delay_get_user_rownum(main_server->sid);
1346
1381
 
1347
1382
  /* Prepare for manipulating the table. */
1348
1383
  if (delay_table_load(FALSE) < 0) {