LPFN_ACCEPTEX ISCAcceptEx;
LPFN_GETACCEPTEXSOCKADDRS ISCGetAcceptExSockaddrs;
+typedef struct isc__socket isc__socket_t;
/*
* Run expensive internal consistency checks.
*/
#else
#define CONSISTENT(sock) do {} while (0)
#endif
-static void consistent(isc_socket_t *sock);
+static void consistent(isc__socket_t *sock);
/*
* Define this macro to control the behavior of connection
};
#define SOCKET_MAGIC ISC_MAGIC('I', 'O', 'i', 'o')
-#define VALID_SOCKET(t) ISC_MAGIC_VALID(t, SOCKET_MAGIC)
+#define VALID_SOCKET(t) ISC_MAGIC_VALID(&t->common, SOCKET_MAGIC)
/*
* IPv6 control information. If the socket is an IPv6 socket we want
*/
#define NRETRIES 10
-struct isc_socket {
+struct isc__socket {
/* Not locked. */
- unsigned int magic;
+ isc_socket_t common;
isc_socketmgr_t *manager;
isc_mutex_t lock;
isc_sockettype_t type;
WSABUF iov[ISC_SOCKET_MAXSCATTERGATHER];
/* Locked by socket lock. */
- ISC_LINK(isc_socket_t) link;
+ ISC_LINK(isc__socket_t) link;
unsigned int references; /* EXTERNAL references */
SOCKET fd; /* file handle */
int pf; /* protocol family */
isc_stats_t *stats;
/* Locked by manager lock. */
- ISC_LIST(isc_socket_t) socklist;
+ ISC_LIST(isc__socket_t) socklist;
bool bShutdown;
isc_condition_t shutdown_ok;
HANDLE hIoCompletionPort;
static isc_result_t socket_create(isc_socketmgr_t *manager0, int pf,
isc_sockettype_t type,
- isc_socket_t **socketp,
- isc_socket_t *dup_socket);
+ isc__socket_t **socketp,
+ isc__socket_t *dup_socket);
static isc_threadresult_t WINAPI SocketIoThread(LPVOID ThreadContext);
-static void maybe_free_socket(isc_socket_t **, int);
-static void free_socket(isc_socket_t **, int);
-static bool senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev);
-static bool acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev);
-static bool connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev);
-static void send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev);
-static void send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev);
-static void send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev);
-static void send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev);
-static void send_recvdone_abort(isc_socket_t *sock, isc_result_t result);
-static void send_connectdone_abort(isc_socket_t *sock, isc_result_t result);
-static void queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev);
-static void queue_receive_request(isc_socket_t *sock);
+static void maybe_free_socket(isc__socket_t **, int);
+static void free_socket(isc__socket_t **, int);
+static bool senddone_is_active(isc__socket_t *sock, isc_socketevent_t *dev);
+static bool acceptdone_is_active(isc__socket_t *sock, isc_socket_newconnev_t *dev);
+static bool connectdone_is_active(isc__socket_t *sock, isc_socket_connev_t *dev);
+static void send_recvdone_event(isc__socket_t *sock, isc_socketevent_t **dev);
+static void send_senddone_event(isc__socket_t *sock, isc_socketevent_t **dev);
+static void send_acceptdone_event(isc__socket_t *sock, isc_socket_newconnev_t **adev);
+static void send_connectdone_event(isc__socket_t *sock, isc_socket_connev_t **cdev);
+static void send_recvdone_abort(isc__socket_t *sock, isc_result_t result);
+static void send_connectdone_abort(isc__socket_t *sock, isc_result_t result);
+static void queue_receive_event(isc__socket_t *sock, isc_task_t *task, isc_socketevent_t *dev);
+static void queue_receive_request(isc__socket_t *sock);
/*
* This is used to dump the contents of the sock structure
* it should only be used interactively.
*/
void
-sock_dump(isc_socket_t *sock) {
+sock_dump(isc__socket_t *sock) {
isc_socketevent_t *ldev;
isc_socket_newconnev_t *ndev;
isc_socket_connev_t *cdev;
printf("\t\tconnected: %u\n", sock->connected);
printf("\t\tbound: %u\n", sock->bound);
printf("\t\tpending_iocp: %u\n", sock->pending_iocp);
- printf("\t\tsocket type: %d\n", sock->type);
+ printf("\t\tsocket type: %d\n", sock->common.type);
printf("\n\t\tSock Recv List\n");
ldev = ISC_LIST_HEAD(sock->recv_list);
}
static void
-socket_log(int lineno, isc_socket_t *sock, const isc_sockaddr_t *address,
+socket_log(int lineno, isc__socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...) ISC_FORMAT_PRINTF(10, 11);
* and have our worker pool of threads process them.
*/
void
-iocompletionport_update(isc_socket_t *sock) {
+iocompletionport_update(isc__socket_t *sock) {
HANDLE hiocp;
char strbuf[ISC_STRERRORSIZE];
* The socket is locked before calling this function
*/
void
-socket_close(isc_socket_t *sock) {
+socket_close(isc__socket_t *sock) {
REQUIRE(sock != NULL);
}
int
-internal_sendmsg(isc_socket_t *sock, IoCompletionInfo *lpo,
+internal_sendmsg(isc__socket_t *sock, IoCompletionInfo *lpo,
struct msghdr *messagehdr, int flags, int *Error)
{
int Result;
}
static void
-queue_receive_request(isc_socket_t *sock) {
+queue_receive_request(isc__socket_t *sock) {
DWORD Flags = 0;
DWORD NumBytes = 0;
int Result;
}
static void
-socket_log(int lineno, isc_socket_t *sock, const isc_sockaddr_t *address,
+socket_log(int lineno, isc__socket_t *sock, const isc_sockaddr_t *address,
isc_logcategory_t *category, isc_logmodule_t *module, int level,
isc_msgcat_t *msgcat, int msgset, int message,
const char *fmt, ...)
* on the buffer linked list for this function to be meaningful.
*/
static void
-build_msghdr_send(isc_socket_t *sock, isc_socketevent_t *dev,
+build_msghdr_send(isc__socket_t *sock, isc_socketevent_t *dev,
struct msghdr *msg, char *cmsg, WSABUF *iov,
IoCompletionInfo *lpo)
{
}
static void
-set_dev_address(const isc_sockaddr_t *address, isc_socket_t *sock,
+set_dev_address(const isc_sockaddr_t *address, isc__socket_t *sock,
isc_socketevent_t *dev)
{
- if (sock->type == isc_sockettype_udp) {
+ if (sock->common.type == isc_sockettype_udp) {
if (address != NULL)
dev->address = *address;
else
dev->address = sock->address;
- } else if (sock->type == isc_sockettype_tcp) {
+ } else if (sock->common.type == isc_sockettype_tcp) {
INSIST(address == NULL);
dev->address = sock->address;
}
}
static isc_socketevent_t *
-allocate_socketevent(isc_mem_t *mctx, isc_socket_t *sock,
+allocate_socketevent(isc_mem_t *mctx, isc__socket_t *sock,
isc_eventtype_t eventtype, isc_taskaction_t action,
void *arg)
{
#if defined(ISC_SOCKET_DEBUG)
static void
-dump_msg(struct msghdr *msg, isc_socket_t *sock) {
+dump_msg(struct msghdr *msg, isc__socket_t *sock) {
unsigned int i;
printf("MSGHDR %p, Socket #: %Iu\n", msg, sock->fd);
* map the error code
*/
int
-map_socket_error(isc_socket_t *sock, int windows_errno, int *isc_errno,
+map_socket_error(isc__socket_t *sock, int windows_errno, int *isc_errno,
char *errorstring, size_t bufsize) {
int doreturn;
}
static void
-fill_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
+fill_recv(isc__socket_t *sock, isc_socketevent_t *dev) {
isc_region_t r;
int copylen;
isc_buffer_t *buffer;
INSIST(sock->recvbuf.remaining > 0);
INSIST(sock->pending_recv == 0);
- if (sock->type == isc_sockettype_udp) {
+ if (sock->common.type == isc_sockettype_udp) {
dev->address.length = sock->recvbuf.from_addr_len;
memmove(&dev->address.type, &sock->recvbuf.from_addr,
sock->recvbuf.from_addr_len);
sock->recvbuf.remaining = 0;
return;
}
- } else if (sock->type == isc_sockettype_tcp) {
+ } else if (sock->common.type == isc_sockettype_tcp) {
dev->address = sock->address;
}
* 1k of space, we will toss the remaining 3k of data. TCP
* will keep the extra data around and use it for later requests.
*/
- if (sock->type == isc_sockettype_udp)
+ if (sock->common.type == isc_sockettype_udp)
sock->recvbuf.remaining = 0;
}
* As each done event is filled, send it along its way.
*/
static void
-completeio_recv(isc_socket_t *sock)
+completeio_recv(isc__socket_t *sock)
{
isc_socketevent_t *dev;
* No other return values are possible.
*/
static int
-completeio_send(isc_socket_t *sock, isc_socketevent_t *dev,
+completeio_send(isc__socket_t *sock, isc_socketevent_t *dev,
struct msghdr *messagehdr, int cc, int send_errno)
{
char strbuf[ISC_STRERRORSIZE];
}
static int
-startio_send(isc_socket_t *sock, isc_socketevent_t *dev, int *nbytes,
+startio_send(isc__socket_t *sock, isc_socketevent_t *dev, int *nbytes,
int *send_errno)
{
char *cmsg = NULL;
}
static void
-use_min_mtu(isc_socket_t *sock) {
+use_min_mtu(isc__socket_t *sock) {
#ifdef IPV6_USE_MIN_MTU
/* use minimum MTU */
if (sock->pf == AF_INET6) {
static isc_result_t
allocate_socket(isc_socketmgr_t *manager, isc_sockettype_t type,
- isc_socket_t **socketp) {
- isc_socket_t *sock;
+ isc__socket_t **socketp) {
+ isc__socket_t *sock;
isc_result_t result;
sock = isc_mem_get(manager->mctx, sizeof(*sock));
if (sock == NULL)
return (ISC_R_NOMEMORY);
- sock->magic = 0;
+ sock->common.magic = 0;
sock->references = 0;
sock->manager = manager;
- sock->type = type;
+ sock->common.type = type;
sock->fd = INVALID_SOCKET;
ISC_LINK_INIT(sock, link);
socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
"allocated");
- sock->magic = SOCKET_MAGIC;
+ sock->common.magic = SOCKET_MAGIC;
*socketp = sock;
return (ISC_R_SUCCESS);
* Verify that the socket state is consistent.
*/
static void
-consistent(isc_socket_t *sock) {
+consistent(isc__socket_t *sock) {
isc_socketevent_t *dev;
isc_socket_newconnev_t *nev;
* to hold on to this pointer are allowed.
*/
static void
-maybe_free_socket(isc_socket_t **socketp, int lineno) {
- isc_socket_t *sock = *socketp;
+maybe_free_socket(isc__socket_t **socketp, int lineno) {
+ isc__socket_t *sock = *socketp;
*socketp = NULL;
INSIST(VALID_SOCKET(sock));
}
void
-free_socket(isc_socket_t **sockp, int lineno) {
+free_socket(isc__socket_t **sockp, int lineno) {
isc_socketmgr_t *manager;
- isc_socket_t *sock = *sockp;
+ isc__socket_t *sock = *sockp;
*sockp = NULL;
/*
"freeing socket line %d fd %d lock %p semaphore %p",
lineno, sock->fd, &sock->lock, sock->lock.LockSemaphore);
- sock->magic = 0;
+ sock->common.magic = 0;
DESTROYLOCK(&sock->lock);
if (sock->recvbuf.base != NULL)
*/
static isc_result_t
socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
- isc_socket_t **socketp, isc_socket_t *dup_socket)
+ isc__socket_t **socketp, isc__socket_t *dup_socket)
{
- isc_socket_t *sock = NULL;
+ isc__socket_t *sock = NULL;
isc_result_t result;
#if defined(USE_CMSG)
int on = 1;
if (dup_socket) {
#ifndef ISC_ALLOW_MAPPED
- isc_socket_ipv6only(sock, true);
+ isc_socket_ipv6only((isc_socket_t *)sock, true);
#endif
if (dup_socket->bound) {
isc_sockaddr_t local;
- result = isc_socket_getsockname(dup_socket, &local);
+ result = isc_socket_getsockname(
+ (isc_socket_t *)dup_socket, &local);
if (result != ISC_R_SUCCESS) {
- isc_socket_close(sock);
+ isc_socket_close((isc_socket_t *)sock);
return (result);
}
- result = isc_socket_bind(sock, &local,
+ result = isc_socket_bind((isc_socket_t *)sock, &local,
ISC_SOCKET_REUSEADDRESS);
if (result != ISC_R_SUCCESS) {
- isc_socket_close(sock);
+ isc_socket_close((isc_socket_t *)sock);
return (result);
}
}
isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp)
{
- return (socket_create(manager, pf, type, socketp, NULL));
+ return (socket_create(manager, pf, type, (isc__socket_t**) socketp,
+ NULL));
}
isc_result_t
-isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
+isc_socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
+ isc__socket_t *sock = (isc__socket_t*) sock0;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
- return (socket_create(sock->manager, sock->pf, sock->type,
- socketp, sock));
+ return (socket_create(sock->manager, sock->pf, sock->common.type,
+ (isc__socket_t**) socketp, sock));
}
isc_result_t
-isc_socket_open(isc_socket_t *sock) {
+isc_socket_open(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t*) sock0;
REQUIRE(VALID_SOCKET(sock));
return (ISC_R_NOTIMPLEMENTED);
* Attach to a socket. Caller must explicitly detach when it is done.
*/
void
-isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
+isc_socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
+ isc__socket_t *sock = (isc__socket_t*) sock0;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
sock->references++;
UNLOCK(&sock->lock);
- *socketp = sock;
+ *socketp = sock0;
}
/*
*/
void
isc_socket_detach(isc_socket_t **socketp) {
- isc_socket_t *sock;
+ isc__socket_t *sock;
REQUIRE(socketp != NULL);
- sock = *socketp;
+ sock = (isc__socket_t*) *socketp;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
}
isc_result_t
-isc_socket_close(isc_socket_t *sock) {
+isc_socket_close(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t*) sock0;
REQUIRE(VALID_SOCKET(sock));
return (ISC_R_NOTIMPLEMENTED);
* Caller must have the socket locked if the event is attached to the socket.
*/
static void
-send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
+send_recvdone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
task = (*dev)->ev_sender;
* See comments for send_recvdone_event() above.
*/
static void
-send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
+send_senddone_event(isc__socket_t *sock, isc_socketevent_t **dev) {
isc_task_t *task;
INSIST(dev != NULL && *dev != NULL);
* See comments for send_recvdone_event() above.
*/
static void
-send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev) {
+send_acceptdone_event(isc__socket_t *sock, isc_socket_newconnev_t **adev) {
isc_task_t *task;
INSIST(adev != NULL && *adev != NULL);
* See comments for send_recvdone_event() above.
*/
static void
-send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev) {
+send_connectdone_event(isc__socket_t *sock, isc_socket_connev_t **cdev) {
isc_task_t *task;
INSIST(cdev != NULL && *cdev != NULL);
* Note the socket is locked before entering here
*/
static void
-internal_accept(isc_socket_t *sock, IoCompletionInfo *lpo, int accept_errno) {
+internal_accept(isc__socket_t *sock, IoCompletionInfo *lpo, int accept_errno) {
isc_socket_newconnev_t *adev;
isc_result_t result = ISC_R_SUCCESS;
- isc_socket_t *nsock;
+ isc__socket_t *nsock;
struct sockaddr *localaddr;
int localaddr_len = sizeof(*localaddr);
struct sockaddr *remoteaddr;
if (!acceptdone_is_active(sock, adev))
goto done;
- nsock = adev->newsocket;
+ nsock = (isc__socket_t *)adev->newsocket;
/*
* Pull off the done event.
isc_msgcat, ISC_MSGSET_SOCKET, ISC_MSG_ACCEPTLOCK,
"internal_accept parent %p", sock);
- result = make_nonblock(adev->newsocket->fd);
+ result = make_nonblock(((isc__socket_t*) (adev->newsocket))->fd);
INSIST(result == ISC_R_SUCCESS);
/*
* Use minimum mtu if possible.
*/
- use_min_mtu(adev->newsocket);
+ use_min_mtu((isc__socket_t*)adev->newsocket);
INSIST(setsockopt(nsock->fd, SOL_SOCKET, SO_UPDATE_ACCEPT_CONTEXT,
(char *)&sock->fd, sizeof(sock->fd)) == 0);
* Note that the socket is locked before entering.
*/
static void
-internal_connect(isc_socket_t *sock, IoCompletionInfo *lpo, int connect_errno) {
+internal_connect(isc__socket_t *sock, IoCompletionInfo *lpo, int connect_errno) {
isc_socket_connev_t *cdev;
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
* Loop through the socket, returning ISC_R_EOF for each done event pending.
*/
static void
-send_recvdone_abort(isc_socket_t *sock, isc_result_t result) {
+send_recvdone_abort(isc__socket_t *sock, isc_result_t result) {
isc_socketevent_t *dev;
while (!ISC_LIST_EMPTY(sock->recv_list)) {
* Loop through the socket, returning result for each done event pending.
*/
static void
-send_connectdone_abort(isc_socket_t *sock, isc_result_t result) {
+send_connectdone_abort(isc__socket_t *sock, isc_result_t result) {
isc_socket_connev_t *dev;
while (!ISC_LIST_EMPTY(sock->connect_list)) {
* our data) then arrange for another system recv() call to fill our buffers.
*/
static void
-internal_recv(isc_socket_t *sock, int nbytes)
+internal_recv(isc__socket_t *sock, int nbytes)
{
INSIST(VALID_SOCKET(sock));
* We do check for a recv() of 0 bytes on a TCP stream. This means the remote end
* has closed.
*/
- if (nbytes == 0 && sock->type == isc_sockettype_tcp) {
+ if (nbytes == 0 && sock->common.type == isc_sockettype_tcp) {
send_recvdone_abort(sock, ISC_R_EOF);
maybe_free_socket(&sock, __LINE__);
return;
}
static void
-internal_send(isc_socket_t *sock, isc_socketevent_t *dev,
+internal_send(isc__socket_t *sock, isc_socketevent_t *dev,
struct msghdr *messagehdr, int nbytes, int send_errno, IoCompletionInfo *lpo)
{
buflist_t *buffer;
* Using these ensures we will not double-send an event.
*/
static bool
-senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev)
+senddone_is_active(isc__socket_t *sock, isc_socketevent_t *dev)
{
isc_socketevent_t *ldev;
}
static bool
-acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev)
+acceptdone_is_active(isc__socket_t *sock, isc_socket_newconnev_t *dev)
{
isc_socket_newconnev_t *ldev;
}
static bool
-connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev)
+connectdone_is_active(isc__socket_t *sock, isc_socket_connev_t *dev)
{
isc_socket_connev_t *cdev;
// by the caller.
//
static isc_result_t
-restart_accept(isc_socket_t *parent, IoCompletionInfo *lpo)
+restart_accept(isc__socket_t *parent, IoCompletionInfo *lpo)
{
- isc_socket_t *nsock = lpo->adev->newsocket;
+ isc__socket_t *nsock = (isc__socket_t *)lpo->adev->newsocket;
SOCKET new_fd;
/*
BOOL bSuccess = FALSE;
DWORD nbytes;
IoCompletionInfo *lpo = NULL;
- isc_socket_t *sock = NULL;
+ isc__socket_t *sock = NULL;
int request;
struct msghdr *messagehdr = NULL;
int errval;
sock->pending_iocp--;
sock->pending_accept--;
if (acceptdone_is_active(sock, lpo->adev)) {
- closesocket(lpo->adev->newsocket->fd);
- lpo->adev->newsocket->fd = INVALID_SOCKET;
- lpo->adev->newsocket->references--;
- free_socket(&lpo->adev->newsocket, __LINE__);
+ isc__socket_t *newsocket = (isc__socket_t*) lpo->adev->newsocket;
+ closesocket(newsocket->fd);
+ newsocket->fd = INVALID_SOCKET;
+ newsocket->references--;
+ free_socket(&newsocket, __LINE__);
+ lpo->adev->newsocket = NULL;
lpo->adev->result = isc_result;
socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
"canceled_accept");
}
static void
-queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev)
+queue_receive_event(isc__socket_t *sock, isc_task_t *task, isc_socketevent_t *dev)
{
isc_task_t *ntask = NULL;
* Caller must have the socket locked.
*/
static isc_result_t
-socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
unsigned int flags)
{
isc_result_t result = ISC_R_SUCCESS;
}
isc_result_t
-isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
+ isc__socket_t *sock = (isc__socket_t*) sock0;
isc_socketevent_t *dev;
isc_socketmgr_t *manager;
unsigned int iocount;
/*
* UDP sockets are always partial read
*/
- if (sock->type == isc_sockettype_udp)
+ if (sock->common.type == isc_sockettype_udp)
dev->minimum = 1;
else {
if (minimum == 0)
}
isc_result_t
-isc_socket_recv(isc_socket_t *sock, isc_region_t *region,
+isc_socket_recv(isc_socket_t *sock0, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
+ isc__socket_t *sock = (isc__socket_t*) sock0;
isc_socketevent_t *dev;
isc_socketmgr_t *manager;
isc_result_t ret;
return (ISC_R_NOMEMORY);
}
- ret = isc_socket_recv2(sock, region, minimum, task, dev, 0);
+ ret = isc_socket_recv2((isc__socket_t*)sock, region, minimum, task,
+ dev, 0);
UNLOCK(&sock->lock);
return (ret);
}
isc_result_t
-isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
+isc_socket_recv2(isc_socket_t *sock0, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags)
{
isc_result_t ret;
+ isc__socket_t *sock = (isc__socket_t *) sock0;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
/*
* UDP sockets are always partial read.
*/
- if (sock->type == isc_sockettype_udp)
+ if (sock->common.type == isc_sockettype_udp)
event->minimum = 1;
else {
if (minimum == 0)
* Caller must have the socket locked.
*/
static isc_result_t
-socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
+socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
}
isc_result_t
-isc_socket_send(isc_socket_t *sock, isc_region_t *region,
+isc_socket_send(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
/*
* REQUIRE() checking is performed in isc_socket_sendto().
*/
- return (isc_socket_sendto(sock, region, task, action, arg, NULL,
+ return (isc_socket_sendto(sock0, region, task, action, arg, NULL,
NULL));
}
isc_result_t
-isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
+isc_socket_sendto(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
+ isc__socket_t *sock = (isc__socket_t *) sock0;
isc_socketevent_t *dev;
isc_socketmgr_t *manager;
isc_result_t ret;
}
isc_result_t
-isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_sendv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
- return (isc_socket_sendtov2(sock, buflist, task, action, arg, NULL,
+ return (isc_socket_sendtov2(sock0, buflist, task, action, arg, NULL,
NULL, 0));
}
isc_result_t
-isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_sendtov(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
- return (isc_socket_sendtov2(sock, buflist, task, action, arg, address,
+ return (isc_socket_sendtov2(sock0, buflist, task, action, arg, address,
pktinfo, 0));
}
isc_result_t
-isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
+isc_socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
+ isc__socket_t *sock = (isc__socket_t *) sock0;
isc_socketevent_t *dev;
isc_socketmgr_t *manager;
unsigned int iocount;
}
isc_result_t
-isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
+isc_socket_sendto2(isc_socket_t *sock0, isc_region_t *region, isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags)
{
isc_result_t ret;
-
+ isc__socket_t *sock = (isc__socket_t *) sock0;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
CONSISTENT(sock);
REQUIRE((flags & ~(ISC_SOCKFLAG_IMMEDIATE|ISC_SOCKFLAG_NORETRY)) == 0);
if ((flags & ISC_SOCKFLAG_NORETRY) != 0)
- REQUIRE(sock->type == isc_sockettype_udp);
+ REQUIRE(sock->common.type == isc_sockettype_udp);
event->ev_sender = sock;
event->result = ISC_R_UNEXPECTED;
/*
}
isc_result_t
-isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
+isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
{
int bind_errno;
char strbuf[ISC_STRERRORSIZE];
int on = 1;
+ isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
}
isc_result_t
-isc_socket_filter(isc_socket_t *sock, const char *filter) {
- UNUSED(sock);
+isc_socket_filter(isc_socket_t *sock0, const char *filter) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
UNUSED(filter);
REQUIRE(VALID_SOCKET(sock));
* as well keep things simple rather than having to track them.
*/
isc_result_t
-isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
+isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
char strbuf[ISC_STRERRORSIZE];
#if defined(ENABLE_TCP_FASTOPEN) && defined(TCP_FASTOPEN)
char on = 1;
#endif
-
+ isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
REQUIRE(!sock->listener);
REQUIRE(sock->bound);
- REQUIRE(sock->type == isc_sockettype_tcp);
+ REQUIRE(sock->common.type == isc_sockettype_tcp);
if (backlog == 0)
backlog = SOMAXCONN;
* This should try to do aggressive accept() XXXMLG
*/
isc_result_t
-isc_socket_accept(isc_socket_t *sock,
+isc_socket_accept(isc_socket_t *sock0,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
+ isc__socket_t *sock = (isc__socket_t *)sock0;
isc_socket_newconnev_t *adev;
isc_socketmgr_t *manager;
isc_task_t *ntask = NULL;
- isc_socket_t *nsock;
+ isc__socket_t *nsock;
isc_result_t result;
IoCompletionInfo *lpo;
}
ISC_LINK_INIT(adev, ev_link);
- result = allocate_socket(manager, sock->type, &nsock);
+ result = allocate_socket(manager, sock->common.type, &nsock);
if (result != ISC_R_SUCCESS) {
isc_event_free((isc_event_t **)&adev);
UNLOCK(&sock->lock);
nsock->references++;
adev->ev_sender = ntask;
- adev->newsocket = nsock;
+ adev->newsocket = (isc_socket_t *)nsock;
_set_state(nsock, SOCK_ACCEPT);
/*
}
isc_result_t
-isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
+isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
+ isc__socket_t *sock = (isc__socket_t *)sock0;
char strbuf[ISC_STRERRORSIZE];
isc_socket_connev_t *cdev;
isc_task_t *ntask = NULL;
return (ISC_R_SUCCESS);
}
- if ((sock->type == isc_sockettype_tcp) && !sock->pending_connect) {
+ if ((sock->common.type == isc_sockettype_tcp) && !sock->pending_connect) {
/*
* Queue io completion for an accept().
*/
INSIST(!ISC_LINK_LINKED(cdev, ev_link));
ISC_LIST_ENQUEUE(sock->connect_list, cdev, ev_link);
sock->pending_iocp++;
- } else if (sock->type == isc_sockettype_tcp) {
+ } else if (sock->common.type == isc_sockettype_tcp) {
INSIST(sock->pending_connect);
INSIST(isc_sockaddr_equal(&sock->address, addr));
isc_task_attach(task, &ntask);
}
isc_result_t
-isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
+isc_socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
isc_result_t result;
+ isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
REQUIRE(addressp != NULL);
}
isc_result_t
-isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
+isc_socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
socklen_t len;
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
* queued for task "task" of type "how". "how" is a bitmask.
*/
void
-isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
+isc_socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
next = ISC_LIST_NEXT(dev, ev_link);
if ((task == NULL) || (task == current_task)) {
-
- dev->newsocket->references--;
- closesocket(dev->newsocket->fd);
- dev->newsocket->fd = INVALID_SOCKET;
- free_socket(&dev->newsocket, __LINE__);
+ isc__socket_t *newsocket = (isc__socket_t *)dev->newsocket;
+ newsocket->references--;
+ closesocket(newsocket->fd);
+ newsocket->fd = INVALID_SOCKET;
+ free_socket(&newsocket, __LINE__);
+ dev->newsocket = NULL;
dev->result = ISC_R_CANCELED;
send_acceptdone_event(sock, &dev);
}
isc_sockettype_t
-isc_socket_gettype(isc_socket_t *sock) {
+isc_socket_gettype(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
isc_sockettype_t type;
REQUIRE(VALID_SOCKET(sock));
return (ISC_R_CONNREFUSED);
}
- type = sock->type;
+ type = sock->common.type;
UNLOCK(&sock->lock);
return (type);
}
void
-isc_socket_ipv6only(isc_socket_t *sock, bool yes) {
+isc_socket_ipv6only(isc_socket_t *sock0, bool yes) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
#if defined(IPV6_V6ONLY)
int onoff = yes ? 1 : 0;
#else
}
void
-isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
+isc_socket_dscp(isc_socket_t *sock0, isc_dscp_t dscp) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
+
#if !defined(IP_TOS) && !defined(IPV6_TCLASS)
UNUSED(dscp);
#else
}
void
-isc_socket_setname(isc_socket_t *socket, const char *name, void *tag) {
+isc_socket_setname(isc_socket_t *sock0, const char *name, void *tag) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
/*
* Name 'socket'.
*/
- REQUIRE(VALID_SOCKET(socket));
+ REQUIRE(VALID_SOCKET(sock));
- LOCK(&socket->lock);
- strlcpy(socket->name, name, sizeof(socket->name));
- socket->tag = tag;
- UNLOCK(&socket->lock);
+ LOCK(&sock->lock);
+ strlcpy(sock->name, name, sizeof(sock->name));
+ sock->tag = tag;
+ UNLOCK(&sock->lock);
}
const char *
-isc_socket_getname(isc_socket_t *socket) {
- return (socket->name);
+isc_socket_getname(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
+ return (sock->name);
}
void *
-isc_socket_gettag(isc_socket_t *socket) {
- return (socket->tag);
+isc_socket_gettag(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
+ return (sock->tag);
}
int
-isc_socket_getfd(isc_socket_t *socket) {
- return ((short) socket->fd);
+isc_socket_getfd(isc_socket_t *sock0) {
+ isc__socket_t *sock = (isc__socket_t *)sock0;
+ return ((short) sock->fd);
}
void
int
isc_socketmgr_renderxml(isc_socketmgr_t *mgr, xmlTextWriterPtr writer)
{
- isc_socket_t *sock = NULL;
+ isc__socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
socklen_t len;
TRY0(xmlTextWriterEndElement(writer));
TRY0(xmlTextWriterWriteElement(writer, ISC_XMLCHAR "type",
- ISC_XMLCHAR _socktype(sock->type)));
+ ISC_XMLCHAR _socktype(sock->common.type)));
if (sock->connected) {
isc_sockaddr_format(&sock->address, peerbuf,
isc_result_t
isc_socketmgr_renderjson(isc_socketmgr_t *mgr, json_object *stats) {
isc_result_t result = ISC_R_SUCCESS;
- isc_socket_t *sock = NULL;
+ isc__socket_t *sock = NULL;
char peerbuf[ISC_SOCKADDR_FORMATSIZE];
isc_sockaddr_t addr;
socklen_t len;
CHECKMEM(obj);
json_object_object_add(entry, "references", obj);
- obj = json_object_new_string(_socktype(sock->type));
+ obj = json_object_new_string(_socktype(sock->common.type));
CHECKMEM(obj);
json_object_object_add(entry, "type", obj);
projects / thirdparty / bind9.git / commitdiff
