{
struct server_socket *srv_sock;
uint16_t port = 389;
- char *ip_str = talloc_strdup(service->mem_ctx, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
srv_sock = service_setup_socket(service, model_ops, ip_str, &port);
#include "includes.h"
+/*
+ auto-close sockets on free
+*/
+static int socket_destructor(void *ptr)
+{
+ struct socket_context *sock = ptr;
+ if (sock->ops->close) {
+ sock->ops->close(sock);
+ }
+ return 0;
+}
+
NTSTATUS socket_create(const char *name, enum socket_type type, struct socket_context **new_sock, uint32_t flags)
{
NTSTATUS status;
(*new_sock)->private_data = NULL;
(*new_sock)->ops = socket_getops_byname(name, type);
if (!(*new_sock)->ops) {
- talloc_free((*new_sock));
+ talloc_free(*new_sock);
return NT_STATUS_INVALID_PARAMETER;
}
status = (*new_sock)->ops->init((*new_sock));
if (!NT_STATUS_IS_OK(status)) {
- talloc_free((*new_sock));
+ talloc_free(*new_sock);
return status;
}
+ talloc_set_destructor(*new_sock, socket_destructor);
+
return NT_STATUS_OK;
}
void socket_destroy(struct socket_context *sock)
{
- if (sock->ops->close) {
- sock->ops->close(sock);
- }
+ /* the close is handled by the destructor */
talloc_free(sock);
}
NTSTATUS socket_accept(struct socket_context *sock, struct socket_context **new_sock, uint32_t flags)
{
+ NTSTATUS status;
+
if (sock->type != SOCKET_TYPE_STREAM) {
return NT_STATUS_INVALID_PARAMETER;
}
return NT_STATUS_NOT_IMPLEMENTED;
}
- return sock->ops->accept(sock, new_sock, flags);
+ status = sock->ops->accept(sock, new_sock, flags);
+
+ if (NT_STATUS_IS_OK(status)) {
+ talloc_set_destructor(*new_sock, socket_destructor);
+ }
+
+ return status;
}
NTSTATUS socket_recv(struct socket_context *sock, TALLOC_CTX *mem_ctx,
/****************************************************************************
check if it's a null mtime
****************************************************************************/
-BOOL null_mtime(time_t mtime)
+static BOOL null_mtime(time_t mtime)
{
return mtime == 0 ||
mtime == (time_t)0xFFFFFFFF ||
return NT_STATUS_INTERNAL_ERROR;
}
- (*gensec_security) = talloc_p(NULL, struct gensec_security);
+ (*gensec_security) = talloc_p(mem_ctx, struct gensec_security);
if (!(*gensec_security)) {
return NT_STATUS_NO_MEMORY;
}
- talloc_set_name(*gensec_security, "gensec_start");
(*gensec_security)->ops = NULL;
if (! *dce_ctx) {
return NT_STATUS_NO_MEMORY;
}
- talloc_set_name(*dce_ctx, "struct dcesrv_context");
(*dce_ctx)->endpoint_list = NULL;
return;
}
- dce_ctx = talloc_p(NULL, struct dcesrv_context);
+ dce_ctx = talloc_p(service, struct dcesrv_context);
if (!dce_ctx) {
DEBUG(0,("talloc_p(mem_ctx, struct dcesrv_context) failed\n"));
return;
}
- talloc_set_name(dce_ctx, "dcesrv_init");
ZERO_STRUCTP(dce_ctx);
dce_ctx->endpoint_list = NULL;
struct in_addr *ifip)
{
struct dcesrv_endpoint *e;
- char *ip_str = talloc_strdup(service->mem_ctx, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
for (e=dce_ctx->endpoint_list;e;e=e->next) {
if (e->ep_description.type == ENDPOINT_TCP) {
{
const char **ports = lp_smb_ports();
int i;
- char *ip_str = talloc_strdup(service->mem_ctx, inet_ntoa(*ifip));
+ char *ip_str = talloc_strdup(service, inet_ntoa(*ifip));
for (i=0;ports[i];i++) {
uint16_t port = atoi(ports[i]);
return;
}
+ talloc_steal(conn, sock);
+
DLIST_ADD(server_socket->connection_list,conn);
/* return to event handling */
return;
}
+ talloc_steal(conn, sock);
+
DLIST_ADD(server_socket->connection_list,conn);
/* return to the event loop */
return;
}
+ talloc_steal(conn, sock);
+
/* TODO: is this MUTEX_LOCK in the right place here?
* --metze
*/
struct event_context;
struct server_context {
- TALLOC_CTX *mem_ctx;
struct server_service *service_list;
struct event_context *events;
};
{
int i;
const char **server_services = lp_server_services();
- TALLOC_CTX *mem_ctx;
struct server_context *srv_ctx;
const struct model_ops *model_ops;
return NULL;
}
- mem_ctx = talloc_init("server_context");
- if (!mem_ctx) {
- DEBUG(0,("talloc_init(server_context) failed\n"));
- return NULL;
- }
-
- srv_ctx = talloc_p(mem_ctx, struct server_context);
+ srv_ctx = talloc_p(NULL, struct server_context);
if (!srv_ctx) {
- DEBUG(0,("talloc_p(mem_ctx, struct server_context) failed\n"));
return NULL;
}
ZERO_STRUCTP(srv_ctx);
- srv_ctx->mem_ctx = mem_ctx;
srv_ctx->events = event_context_init();
if (!srv_ctx->events) {
for (i=0;server_services[i];i++) {
- TALLOC_CTX *mem_ctx2;
const struct server_service_ops *service_ops;
struct server_service *service;
return NULL;
}
- mem_ctx2 = talloc_init("server_service");
-
- service = talloc_p(mem_ctx2, struct server_service);
+ service = talloc_p(srv_ctx, struct server_service);
if (!service) {
- DEBUG(0,("talloc_p(mem_ctx, struct server_service) failed\n"));
return NULL;
}
ZERO_STRUCTP(service);
- service->mem_ctx = mem_ctx2;
service->ops = service_ops;
service->model_ops = model_ops;
service->srv_ctx = srv_ctx;
return NULL;
}
+ talloc_steal(service, socket_ctx);
+
/* ready to listen */
status = socket_set_option(socket_ctx, "SO_KEEPALIVE SO_REUSEADDR=1", NULL);
if (!NT_STATUS_IS_OK(status)) {
fde.handler = model_ops->accept_connection;
ZERO_STRUCTP(srv_sock);
- srv_sock->mem_ctx = srv_sock;
srv_sock->service = service;
srv_sock->socket = socket_ctx;
srv_sock->event.ctx = service->srv_ctx->events;
}
ZERO_STRUCTP(srv_conn);
- srv_conn->mem_ctx = srv_conn;
fde.private = srv_conn;
fde.fd = socket_get_fd(sock);
event_remove_timed(srv_conn->event.ctx, srv_conn->event.idle);
srv_conn->event.idle = NULL;
- talloc_destroy(srv_conn->mem_ctx);
+ talloc_free(srv_conn);
}
void server_io_handler(struct event_context *ev, struct fd_event *fde, time_t t, uint16_t flags)
struct server_socket {
struct server_socket *next,*prev;
- TALLOC_CTX *mem_ctx;
void *private_data;
struct {
struct server_service {
struct server_service *next,*prev;
- TALLOC_CTX *mem_ctx;
void *private_data;
const struct server_service_ops *ops;
struct server_connection {
struct server_connection *next,*prev;
- TALLOC_CTX *mem_ctx;
void *private_data;
struct {