/* Deliver new stream to upper layer */
-static void silc_net_accept_stream(SilcSocketStreamStatus status,
+static void silc_net_accept_stream(SilcResult status,
SilcStream stream, void *context)
{
SilcNetListener listener = (SilcNetListener)context;
/* In case of error, the socket has been destroyed already via
silc_stream_destroy. */
- if (status != SILC_SOCKET_OK)
+ if (status != SILC_OK)
return;
- listener->callback(SILC_NET_OK, stream, listener->context);
+ listener->callback(SILC_OK, stream, listener->context);
}
} /* extern "C" */
listener = (SilcNetListener)silc_calloc(1, sizeof(*listener));
if (!listener) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
listener->schedule = schedule;
listener->socks = (SilcSocket *)silc_calloc(local_ip_count,
sizeof(*listener->socks));
if (!listener->socks) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
} else {
listener->socks = (SilcSocket *)silc_calloc(1, sizeof(*listener->socks));
if (!listener->socks) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
if (l)
delete l;
if (callback)
- callback(SILC_NET_ERROR, NULL, context);
+ callback(SILC_ERR, NULL, context);
if (listener)
silc_net_close_listener(listener);
return NULL;
listener = (SilcNetListener)silc_calloc(1, sizeof(*listener));
if (!listener) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
listener->schedule = schedule;
listener->socks = (SilcSocket *)silc_calloc(port_count,
sizeof(*listener->socks));
if (!listener->socks) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
} else {
listener->socks = (SilcSocket *)silc_calloc(1, sizeof(*listener->socks));
if (!listener->socks) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
if (l)
delete l;
if (callback)
- callback(SILC_NET_ERROR, NULL, context);
+ callback(SILC_ERR, NULL, context);
if (listener)
silc_net_close_listener(listener);
return NULL;
/**************************** TCP/IP connecting *****************************/
-static void silc_net_connect_stream(SilcSocketStreamStatus status,
- SilcStream stream, void *context);
+static void silc_net_connect_stream(SilcResult status,
+ SilcStream stream, void *context);
} /* extern "C" */
if (iStatus != KErrNone) {
if (callback)
- callback(SILC_NET_ERROR, NULL, context);
+ callback(SILC_ERR, NULL, context);
sock->CancelConnect();
delete sock;
ss->Close();
/* TCP stream creation callback */
-static void silc_net_connect_stream(SilcSocketStreamStatus status,
+static void silc_net_connect_stream(SilcResult status,
SilcStream stream, void *context)
{
SilcSymbianTCPConnect *conn = (SilcSymbianTCPConnect *)context;
- SilcNetStatus net_status = SILC_NET_OK;
SILC_LOG_DEBUG(("Socket stream creation status %d", status));
- if (status != SILC_SOCKET_OK) {
- /* In case of error, the socket has been destroyed already via
- silc_stream_destroy. */
- if (status == SILC_SOCKET_UNKNOWN_IP)
- net_status = SILC_NET_UNKNOWN_IP;
- else if (status == SILC_SOCKET_UNKNOWN_HOST)
- net_status = SILC_NET_UNKNOWN_HOST;
- else
- net_status = SILC_NET_ERROR;
- }
-
/* Call connection callback */
if (conn->callback)
- conn->callback(net_status, stream, conn->context);
+ conn->callback(status, stream, conn->context);
else if (stream)
silc_stream_destroy(stream);
{
SilcSymbianTCPConnect *conn;
TInetAddr local, remote;
- SilcNetStatus status;
+ SilcResult status;
TInt ret;
if (!remote_ip_addr || remote_port < 1 || !schedule || !callback)
conn = new SilcSymbianTCPConnect;
if (!conn) {
- callback(SILC_NET_NO_MEMORY, NULL, context);
+ callback(SILC_ERR_OUT_OF_MEMORY, NULL, context);
return NULL;
}
conn->schedule = schedule;
conn->port = remote_port;
conn->remote = strdup(remote_ip_addr);
if (!conn->remote) {
- status = SILC_NET_NO_MEMORY;
+ status = SILC_ERR_OUT_OF_MEMORY;
goto err;
}
/* Allocate socket */
conn->sock = new RSocket;
if (!conn->sock) {
- status = SILC_NET_NO_MEMORY;
+ status = SILC_ERR_OUT_OF_MEMORY;
goto err;
}
/* Allocate socket server */
conn->ss = new RSocketServ;
if (!conn->ss) {
- status = SILC_NET_NO_MEMORY;
+ status = SILC_ERR_OUT_OF_MEMORY;
goto err;
}
ret = conn->ss->Connect();
if (ret != KErrNone) {
SILC_LOG_ERROR(("Error connecting to socket server, error %d", ret));
- status = SILC_NET_ERROR;
+ status = SILC_ERR;
goto err;
}
/* Start async operation */
conn->op = silc_async_alloc(silc_net_connect_abort, NULL, (void *)conn);
if (!conn->op) {
- status = SILC_NET_NO_MEMORY;
+ status = SILC_ERR_OUT_OF_MEMORY;
goto err;
}
sizeof(conn->remote_ip))) {
SILC_LOG_ERROR(("Network (%s) unreachable: could not resolve the "
"host", conn->remote));
- status = SILC_NET_HOST_UNREACHABLE;
+ status = SILC_ERR_UNREACHABLE;
goto err;
}
ret = conn->sock->Open(*conn->ss, KAfInet, KSockStream, KProtocolInetTcp);
if (ret != KErrNone) {
SILC_LOG_ERROR(("Cannot create socket, error %d", ret));
- status = SILC_NET_ERROR;
+ status = SILC_ERR;
goto err;
}
/* Connect to the host */
if (!silc_net_set_sockaddr(&remote, conn->remote_ip, remote_port)) {
SILC_LOG_ERROR(("Cannot connect (cannot set address)"));
- status = SILC_NET_ERROR;
+ status = SILC_ERR;
goto err;
}
conn->Connect(remote);