コード例 #1
0
ファイル: logs.c プロジェクト: 4nY0n0m0u5/nmap
static int check_errlevel(struct log_test_data *ltd, nsock_loglevel_t level) {
  nsock_event_id id;

  nsock_set_loglevel(level);

  ltd->current_level = level;

  ltd->got_dbgfull = 0;
  ltd->got_dbg     = 0;
  ltd->got_info    = 0;
  ltd->got_error   = 0;

  ltd->total   = 0;
  ltd->errcode = 0;

  id = nsock_timer_create(ltd->nsp, nop_handler, 200, NULL);
  nsock_event_cancel(ltd->nsp, id, 0);

  if (ltd->errcode)
    return ltd->errcode;

  if (ltd->total > 0)
    return -EINVAL;

  return 0;
}
コード例 #2
0
ファイル: nsock_test_timers.c プロジェクト: 1chenping/ncrack
int try_cancel_timer(nsock_pool * nsp, int idx, int notify) {
  int res;

  printf("%ld:Attempting to cancel id %li (idx %d) %s notify.\n", time(NULL), ev_ids[idx], idx, ((notify) ? "WITH" : "WITHOUT"));
  res = nsock_event_cancel(nsp, ev_ids[idx], notify);
  printf("Kill of %li %s\n", ev_ids[idx], (res == 0) ? "FAILED" : "SUCCEEDED");
  return res;
}
コード例 #3
0
static void refresh_idle_timer(nsock_pool nsp)
{
    if (o.idletimeout <= 0)
        return;
    nsock_event_cancel(nsp, cs.idle_timer_event_id, 0);
    cs.idle_timer_event_id =
        nsock_timer_create(nsp, idle_timer_handler, o.idletimeout, NULL);
}
コード例 #4
0
ファイル: cancel.c プロジェクト: 4nY0n0m0u5/nmap
static int cancel_udp_run(void *tdata) {
  struct basic_test_data *btd = (struct basic_test_data *)tdata;
  struct sockaddr_in peer;
  nsock_iod iod;
  nsock_event_id id;
  int done = 0;

  iod = nsock_iod_new(btd->nsp, NULL);
  AssertNonNull(iod);

  memset(&peer, 0, sizeof(peer));
  peer.sin_family = AF_INET;
  inet_aton("127.0.0.1", &peer.sin_addr);

  id = nsock_connect_udp(btd->nsp, iod, cancel_handler, (void *)&done,
                         (struct sockaddr *)&peer, sizeof(peer), PORT_UDP);
  nsock_event_cancel(btd->nsp, id, 1);

  nsock_iod_delete(iod, NSOCK_PENDING_SILENT);

  return (done == 1) ? 0 : -ENOEXEC;
}
コード例 #5
0
ファイル: timer.c プロジェクト: 1chenping/ncrack
static void timer_handler(nsock_pool nsp, nsock_event nse, void *tdata) {
  struct timer_test_data *ttd = (struct timer_test_data *)tdata;
  int rnd, rnd2;

  if (nse_status(nse) != NSE_STATUS_SUCCESS) {
    ttd->stop = -nsock_pool_get_error(nsp);
    return;
  }

  if (ttd->timer_count > TIMERS_BUFFLEN - 3)
    return;

  rnd = rand() % ttd->timer_count;
  rnd2 = rand() % 3;

  switch (rnd2) {
    case 0:
      /* Do nothing */
      /* Actually I think I'll create two timers :) */
      add_timer(ttd, rand() % 3000);
      add_timer(ttd, rand() % 3000);
      break;

    case 1:
      /* Try to kill another id (which may or may not be active */
      nsock_event_cancel(nsp, ttd->timer_list[rnd], rand() % 2);
      break;

    case 2:
      /* Create a new timer */
      add_timer(ttd, rand() % 3000);
      break;

    default:
      assert(0);
  }
}
コード例 #6
0
ファイル: nsock_telnet.c プロジェクト: 6e6f36/nmap
void telnet_event_handler(nsock_pool nsp, nsock_event nse, void *mydata) {
  nsock_iod nsi = nse_iod(nse);
  enum nse_status status = nse_status(nse);
  enum nse_type type = nse_type(nse);
  struct sockaddr_in peer;
  struct telnet_state *ts;
  int nbytes;
  char *str;
  int read_timeout = -1;
  int write_timeout = 2000;
  ts = (struct telnet_state *)mydata;

  printf("telnet_event_handler: Received callback of type %s with status %s\n", nse_type2str(type), nse_status2str(status));

  if (status == NSE_STATUS_SUCCESS) {
    switch (type) {
    case NSE_TYPE_CONNECT:
    case NSE_TYPE_CONNECT_SSL:
      nsi_getlastcommunicationinfo(nsi, NULL, NULL, NULL, (struct sockaddr *)&peer, sizeof peer);
      printf("Successfully connected %sto %s:%hu -- start typing lines\n", (type == NSE_TYPE_CONNECT_SSL) ? "(SSL!) " : "", inet_ntoa(peer.sin_addr), peer.sin_port);
      /* First of all, lets add STDIN to our list of watched filehandles */
      if ((ts->stdin_nsi = nsi_new2(nsp, STDIN_FILENO, NULL)) == NULL) {
        fprintf(stderr, "Failed to create stdin msi\n");
        exit(1);
      }

      /* Now lets read from stdin and the network, line buffered (by nsock) */
      ts->latest_readtcpev = nsock_readlines(nsp, ts->tcp_nsi, telnet_event_handler, read_timeout, ts, 1);
      ts->latest_readstdinev = nsock_readlines(nsp, ts->stdin_nsi, telnet_event_handler, read_timeout, ts, 1);
      break;
    case NSE_TYPE_READ:
      str = nse_readbuf(nse, &nbytes);
      if (nsi == ts->tcp_nsi) {
        printf("%s", str);
        /*       printf("Read from tcp socket (%d bytes):\n%s", nbytes, str); */
        ts->latest_readtcpev = nsock_readlines(nsp, ts->tcp_nsi, telnet_event_handler, read_timeout, ts, 1);
      } else {
        /*       printf("Read from  stdin (%d bytes):\n%s", nbytes, str); */
        nsock_write(nsp, ts->tcp_nsi, telnet_event_handler, write_timeout, ts, str, nbytes);
        ts->latest_readstdinev = nsock_readlines(nsp, ts->stdin_nsi, telnet_event_handler, read_timeout, ts, 1);
      }
      break;
    case NSE_TYPE_WRITE:
      /* Nothing to do, really */
      break;
    case NSE_TYPE_TIMER:
      break;
    default:
      fprintf(stderr, "telnet_event_handler: Got bogus type -- quitting\n");
      exit(1);
      break;
    }
  } else if (status == NSE_STATUS_EOF) {
    printf("Got EOF from %s\nCancelling outstanding readevents.\n", (nsi == ts->tcp_nsi) ? "tcp socket" : "stdin");
    /* One of these is the event I am currently handling!  But I wanted to
       be evil when testing this out... */
    if (nsock_event_cancel(nsp, ts->latest_readtcpev, 1) != 0) {
      printf("Cancelled tcp event: %li\n", ts->latest_readtcpev);
    }
    if (nsock_event_cancel(nsp, ts->latest_readstdinev, 1) != 0) {
      printf("Cancelled stdin event: %li\n", ts->latest_readstdinev);
    }
  } else if (status == NSE_STATUS_ERROR) {
    if (nsi_checkssl(nsi)) {
      printf("SSL %s failed: %s\n", nse_type2str(type), ERR_error_string(ERR_get_error(), NULL));
    } else {
      int err;

      err = nse_errorcode(nse);
      printf("%s failed: (%d) %s\n", nse_type2str(type), err, strerror(err));
    }
  }
  return;
}