C++ (Cpp) SILC_FSM_CALL_CONTINUE Examples

Example #1

File: server_st_accept.c Project: FabrizioFabbe/silc

static void
silc_server_accept_auth_compl(SilcConnAuth connauth, SilcBool success,
			      void *context)
{
  SilcServerAccept ac = context;
  ac->auth_success = success;
  SILC_FSM_CALL_CONTINUE(&ac->t);
}

Example #2

File: test_silcnet.c Project: TabTwo/silc-toolkit

static void test_connected(SilcNetStatus status, SilcStream stream,
			   void *context)
{
  Foo f = context;
  SILC_LOG_DEBUG(("Connected to server"));
  f->server_status = status;
  f->server_stream = stream;
  SILC_FSM_CALL_CONTINUE(&f->thread);
}

Example #3

File: silcunixnet.c Project: TabTwo/silc-toolkit

static void silc_net_connect_wait_stream(SilcSocketStreamStatus status,
					 SilcStream stream, void *context)
{
  SilcNetConnect conn = context;
  conn->sop = NULL;
  conn->stream_status = status;
  conn->stream = stream;
  SILC_FSM_CALL_CONTINUE(&conn->fsm);
}

Example #4

File: client_prvmsg.c Project: TabTwo/silc-client

static void silc_client_private_message_resolved(SilcClient client,
						 SilcClientConnection conn,
						 SilcStatus status,
						 SilcDList clients,
						 void *context)
{
  /* If no client found, ignore the private message, a silent error */
  if (!clients)
    silc_fsm_next(context, silc_client_private_message_error);

  /* Continue processing the private message packet */
  SILC_FSM_CALL_CONTINUE(context);
}

Example #5

File: silcconnauth.c Project: TabTwo/silc-toolkit

static void silc_connauth_skr_callback(SilcSKR skr, SilcSKRFind find,
				       SilcSKRStatus status,
				       SilcDList results, void *context)
{
  SilcConnAuth connauth = context;

  silc_skr_find_free(find);

  connauth->public_keys = results;
  connauth->skr_status = status;

  SILC_FSM_CALL_CONTINUE(connauth->fsm);
}

Example #6

File: client_connect.c Project: TabTwo/silc-client

static void silc_client_connect_auth_method(SilcAuthMethod auth_meth,
					    const void *auth,
					    SilcUInt32 auth_len,
					    void *context)
{
  SilcFSMThread fsm = context;
  SilcClientConnection conn = silc_fsm_get_context(fsm);

  conn->internal->params.auth_method = auth_meth;
  if (auth_meth == SILC_AUTH_PASSWORD)
    conn->internal->params.auth = silc_memdup(auth, auth_len);
  else
    conn->internal->params.auth = (void *)auth;
  conn->internal->params.auth_len = auth_len;

  SILC_FSM_CALL_CONTINUE(fsm);
}

Example #7

File: client_ftp.c Project: TabTwo/silc-client

static void silc_client_ftp_client_resolved(SilcClient client,
					    SilcClientConnection conn,
					    SilcStatus status,
					    SilcDList clients,
					    void *context)
{
  SilcFSMThread thread = context;
  SilcPacket packet = silc_fsm_get_state_context(thread);

  /* If no client found, ignore the packet, a silent error */
  if (!clients) {
    silc_packet_free(packet);
    silc_fsm_finish(thread);
    return;
  }

  /* Continue processing the packet */
  SILC_FSM_CALL_CONTINUE(context);
}

Example #8

File: test_silcfsm.c Project: TabTwo/silc-toolkit

static void async_call_cb(void *context)
{
  Foo f = context;
  SILC_LOG_DEBUG(("Callback, continue to next state"));
  SILC_FSM_CALL_CONTINUE(f->fsm);
}

Example #9

File: client_connect.c Project: TabTwo/silc-client

static void silc_client_connect_callback(SilcNetStatus status,
					 SilcStream stream, void *context)
{
  SilcFSMThread fsm = context;
  SilcClientConnection conn = silc_fsm_get_context(fsm);
  SilcClient client = conn->client;

  conn->internal->op = NULL;
  if (conn->internal->verbose) {
    switch (status) {
    case SILC_NET_OK:
      break;
    case SILC_NET_UNKNOWN_IP:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s: unknown IP address",
		   conn->remote_host);
      break;
    case SILC_NET_UNKNOWN_HOST:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s: unknown host name",
		   conn->remote_host);
      break;
    case SILC_NET_HOST_UNREACHABLE:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s: network unreachable",
		   conn->remote_host);
      break;
    case SILC_NET_CONNECTION_REFUSED:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s: connection refused",
		   conn->remote_host);
      break;
    case SILC_NET_CONNECTION_TIMEOUT:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s: connection timeout",
		   conn->remote_host);
      break;
    default:
      client->internal->ops->say(
		   client, conn, SILC_CLIENT_MESSAGE_ERROR,
		   "Could not connect to host %s",
		   conn->remote_host);
      break;
    }
  }

  if (status != SILC_NET_OK) {
    /* Notify application of failure */
    SILC_LOG_DEBUG(("Connecting failed"));
    conn->internal->status = SILC_CLIENT_CONN_ERROR;
    silc_fsm_next(fsm, silc_client_st_connect_error);
    SILC_FSM_CALL_CONTINUE(fsm);
    return;
  }

  /* Connection created successfully */
  SILC_LOG_DEBUG(("Connected"));
  conn->internal->user_stream = stream;
  SILC_FSM_CALL_CONTINUE(fsm);
}