mirror of
https://github.com/samba-team/samba.git
synced 2024-12-24 21:34:56 +03:00
2e0e416676
This will replace source4/lib/socket/. metze
232 lines
5.9 KiB
C
232 lines
5.9 KiB
C
/*
|
|
Unix SMB/CIFS implementation.
|
|
|
|
Copyright (C) Stefan Metzmacher 2009
|
|
|
|
** NOTE! The following LGPL license applies to the tevent
|
|
** library. This does NOT imply that all of Samba is released
|
|
** under the LGPL
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Lesser General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 3 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public
|
|
License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "replace.h"
|
|
#include "system/network.h"
|
|
#include "tsocket.h"
|
|
#include "tsocket_internal.h"
|
|
|
|
static int tsocket_context_destructor(struct tsocket_context *sock)
|
|
{
|
|
tsocket_disconnect(sock);
|
|
return 0;
|
|
}
|
|
|
|
struct tsocket_context *_tsocket_context_create(TALLOC_CTX *mem_ctx,
|
|
const struct tsocket_context_ops *ops,
|
|
void *pstate,
|
|
size_t psize,
|
|
const char *type,
|
|
const char *location)
|
|
{
|
|
void **ppstate = (void **)pstate;
|
|
struct tsocket_context *sock;
|
|
|
|
sock = talloc_zero(mem_ctx, struct tsocket_context);
|
|
if (!sock) {
|
|
return NULL;
|
|
}
|
|
sock->ops = ops;
|
|
sock->location = location;
|
|
sock->private_data = talloc_size(sock, psize);
|
|
if (!sock->private_data) {
|
|
talloc_free(sock);
|
|
return NULL;
|
|
}
|
|
talloc_set_name_const(sock->private_data, type);
|
|
|
|
talloc_set_destructor(sock, tsocket_context_destructor);
|
|
|
|
*ppstate = sock->private_data;
|
|
return sock;
|
|
}
|
|
|
|
int tsocket_set_event_context(struct tsocket_context *sock,
|
|
struct tevent_context *ev)
|
|
{
|
|
return sock->ops->set_event_context(sock, ev);
|
|
}
|
|
|
|
int tsocket_set_readable_handler(struct tsocket_context *sock,
|
|
tsocket_event_handler_t handler,
|
|
void *private_data)
|
|
{
|
|
return sock->ops->set_read_handler(sock, handler, private_data);
|
|
}
|
|
|
|
int tsocket_set_writeable_handler(struct tsocket_context *sock,
|
|
tsocket_event_handler_t handler,
|
|
void *private_data)
|
|
{
|
|
return sock->ops->set_write_handler(sock, handler, private_data);
|
|
}
|
|
|
|
int tsocket_connect(struct tsocket_context *sock,
|
|
const struct tsocket_address *remote_addr)
|
|
{
|
|
return sock->ops->connect_to(sock, remote_addr);
|
|
}
|
|
|
|
int tsocket_listen(struct tsocket_context *sock,
|
|
int queue_size)
|
|
{
|
|
return sock->ops->listen_on(sock, queue_size);
|
|
}
|
|
|
|
int _tsocket_accept(struct tsocket_context *sock,
|
|
TALLOC_CTX *mem_ctx,
|
|
struct tsocket_context **new_sock,
|
|
const char *location)
|
|
{
|
|
return sock->ops->accept_new(sock, mem_ctx, new_sock, location);
|
|
}
|
|
|
|
ssize_t tsocket_pending(struct tsocket_context *sock)
|
|
{
|
|
return sock->ops->pending_data(sock);
|
|
}
|
|
|
|
int tsocket_readv(struct tsocket_context *sock,
|
|
const struct iovec *vector, size_t count)
|
|
{
|
|
return sock->ops->readv_data(sock, vector, count);
|
|
}
|
|
|
|
int tsocket_writev(struct tsocket_context *sock,
|
|
const struct iovec *vector, size_t count)
|
|
{
|
|
return sock->ops->writev_data(sock, vector, count);
|
|
}
|
|
|
|
ssize_t tsocket_recvfrom(struct tsocket_context *sock,
|
|
uint8_t *data, size_t len,
|
|
TALLOC_CTX *addr_ctx,
|
|
struct tsocket_address **src_addr)
|
|
{
|
|
return sock->ops->recvfrom_data(sock, data, len, addr_ctx, src_addr);
|
|
}
|
|
|
|
ssize_t tsocket_sendto(struct tsocket_context *sock,
|
|
const uint8_t *data, size_t len,
|
|
const struct tsocket_address *dest_addr)
|
|
{
|
|
return sock->ops->sendto_data(sock, data, len, dest_addr);
|
|
}
|
|
|
|
int tsocket_get_status(const struct tsocket_context *sock)
|
|
{
|
|
return sock->ops->get_status(sock);
|
|
}
|
|
|
|
int _tsocket_get_local_address(const struct tsocket_context *sock,
|
|
TALLOC_CTX *mem_ctx,
|
|
struct tsocket_address **local_addr,
|
|
const char *location)
|
|
{
|
|
return sock->ops->get_local_address(sock, mem_ctx,
|
|
local_addr, location);
|
|
}
|
|
|
|
int _tsocket_get_remote_address(const struct tsocket_context *sock,
|
|
TALLOC_CTX *mem_ctx,
|
|
struct tsocket_address **remote_addr,
|
|
const char *location)
|
|
{
|
|
return sock->ops->get_remote_address(sock, mem_ctx,
|
|
remote_addr, location);
|
|
}
|
|
|
|
int tsocket_get_option(const struct tsocket_context *sock,
|
|
const char *option,
|
|
TALLOC_CTX *mem_ctx,
|
|
char **value)
|
|
{
|
|
return sock->ops->get_option(sock, option, mem_ctx, value);
|
|
}
|
|
|
|
int tsocket_set_option(const struct tsocket_context *sock,
|
|
const char *option,
|
|
bool force,
|
|
const char *value)
|
|
{
|
|
return sock->ops->set_option(sock, option, force, value);
|
|
}
|
|
|
|
void tsocket_disconnect(struct tsocket_context *sock)
|
|
{
|
|
sock->ops->disconnect(sock);
|
|
}
|
|
|
|
struct tsocket_address *_tsocket_address_create(TALLOC_CTX *mem_ctx,
|
|
const struct tsocket_address_ops *ops,
|
|
void *pstate,
|
|
size_t psize,
|
|
const char *type,
|
|
const char *location)
|
|
{
|
|
void **ppstate = (void **)pstate;
|
|
struct tsocket_address *addr;
|
|
|
|
addr = talloc_zero(mem_ctx, struct tsocket_address);
|
|
if (!addr) {
|
|
return NULL;
|
|
}
|
|
addr->ops = ops;
|
|
addr->location = location;
|
|
addr->private_data = talloc_size(addr, psize);
|
|
if (!addr->private_data) {
|
|
talloc_free(addr);
|
|
return NULL;
|
|
}
|
|
talloc_set_name_const(addr->private_data, type);
|
|
|
|
*ppstate = addr->private_data;
|
|
return addr;
|
|
}
|
|
|
|
char *tsocket_address_string(const struct tsocket_address *addr,
|
|
TALLOC_CTX *mem_ctx)
|
|
{
|
|
if (!addr) {
|
|
return talloc_strdup(mem_ctx, "NULL");
|
|
}
|
|
return addr->ops->string(addr, mem_ctx);
|
|
}
|
|
|
|
struct tsocket_address *_tsocket_address_copy(const struct tsocket_address *addr,
|
|
TALLOC_CTX *mem_ctx,
|
|
const char *location)
|
|
{
|
|
return addr->ops->copy(addr, mem_ctx, location);
|
|
}
|
|
|
|
int _tsocket_address_create_socket(const struct tsocket_address *addr,
|
|
enum tsocket_type type,
|
|
TALLOC_CTX *mem_ctx,
|
|
struct tsocket_context **sock,
|
|
const char *location)
|
|
{
|
|
return addr->ops->create_socket(addr, type, mem_ctx, sock, location);
|
|
}
|
|
|