r13561: Turn all dcerpc connect and socket functions to async version.
authorRafal Szczesniak <mimir@samba.org>
Sun, 19 Feb 2006 16:58:48 +0000 (16:58 +0000)
committerGerald (Jerry) Carter <jerry@samba.org>
Wed, 10 Oct 2007 18:51:57 +0000 (13:51 -0500)
Now, each rpc interface (named pipe, tcp/ip, lrpc and unix
socket) works asynchronously.
Comments to follow.

rafal

source/librpc/rpc/dcerpc_connect.c
source/librpc/rpc/dcerpc_sock.c
source/librpc/rpc/dcerpc_util.c

index 67dfda6d7a75807dd1e9c0e5e51b7b5842e716a5..fa02bca697e93b2d57f8ba80320eb16881205490 100644 (file)
@@ -324,3 +324,246 @@ NTSTATUS dcerpc_pipe_connect_ncacn_np_smb2(TALLOC_CTX *mem_ctx,
        c = dcerpc_pipe_connect_ncacn_np_smb2_send(mem_ctx, io);
        return dcerpc_pipe_connect_ncacn_np_smb2_recv(c);
 }
+
+
+struct pipe_ip_tcp_state {
+       struct dcerpc_pipe_connect io;
+       const char *host;
+       uint32_t port;
+};
+
+
+void continue_pipe_open_ncacn_ip_tcp(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+       struct pipe_ip_tcp_state *s = talloc_get_type(c->private_data,
+                                                     struct pipe_ip_tcp_state);
+
+       c->status = dcerpc_pipe_open_tcp_recv(ctx);
+       if (!NT_STATUS_IS_OK(c->status)) {
+               DEBUG(0,("Failed to connect to %s:%d - %s\n", s->host, s->port,
+                        nt_errstr(c->status)));
+               composite_error(c, c->status);
+               return;
+       }
+
+       composite_done(c);
+}
+
+
+struct composite_context* dcerpc_pipe_connect_ncacn_ip_tcp_send(TALLOC_CTX *mem_ctx,
+                                                               struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c;
+       struct pipe_ip_tcp_state *s;
+       struct composite_context *pipe_req;
+
+       /* composite context allocation and setup */
+       c = talloc_zero(mem_ctx, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_ip_tcp_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = io->pipe->conn->event_ctx;
+
+       s->io    = *io;
+       s->host  = talloc_strdup(c, io->binding->host);
+       s->port  = atoi(io->binding->endpoint);   /* port number is a binding endpoint here */
+
+       pipe_req = dcerpc_pipe_open_tcp_send(s->io.pipe->conn, s->host, s->port);
+       if (pipe_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       composite_continue(c, pipe_req, continue_pipe_open_ncacn_ip_tcp, c);
+done:
+       return c;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp_recv(struct composite_context *c)
+{
+       NTSTATUS status = composite_wait(c);
+       
+       talloc_free(c);
+       return status;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(TALLOC_CTX *mem_ctx,
+                                         struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c;
+       c = dcerpc_pipe_connect_ncacn_ip_tcp_send(mem_ctx, io);
+       return dcerpc_pipe_connect_ncacn_ip_tcp_recv(c);
+}
+
+
+struct pipe_unix_state {
+       struct dcerpc_pipe_connect io;
+       const char *path;
+};
+
+
+void continue_pipe_open_ncacn_unix_stream(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+       struct pipe_unix_state *s = talloc_get_type(c->private_data,
+                                                   struct pipe_unix_state);
+       
+       c->status = dcerpc_pipe_open_unix_stream_recv(ctx);
+       if (!NT_STATUS_IS_OK(c->status)) {
+               DEBUG(0,("Failed to open unix socket %s - %s\n",
+                        s->io.binding->endpoint, nt_errstr(c->status)));
+               composite_error(c, c->status);
+               return;
+       }
+
+       composite_done(c);
+}
+
+
+struct composite_context* dcerpc_pipe_connect_ncacn_unix_stream_send(TALLOC_CTX *mem_ctx,
+                                                                    struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c;
+       struct pipe_unix_state *s;
+       struct composite_context *pipe_req;
+
+       /* composite context allocation and setup */
+       c = talloc_zero(mem_ctx, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_unix_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = io->pipe->conn->event_ctx;
+       
+       s->io = *io;
+
+       if (!io->binding->endpoint) {
+               DEBUG(0, ("Path to unix socket not specified\n"));
+               composite_error(c, NT_STATUS_INVALID_PARAMETER);
+               goto done;
+       }
+
+       s->path  = talloc_strdup(c, io->binding->endpoint);  /* path is a binding endpoint here */
+       
+       pipe_req = dcerpc_pipe_open_unix_stream_send(s->io.pipe->conn, s->path);
+       if (pipe_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       composite_continue(c, pipe_req, continue_pipe_open_ncacn_unix_stream, c);
+done:
+       return c;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncacn_unix_stream_recv(struct composite_context *c)
+{
+       NTSTATUS status = composite_wait(c);
+
+       talloc_free(c);
+       return status;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncacn_unix_stream(TALLOC_CTX *mem_ctx,
+                                              struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c;
+       c = dcerpc_pipe_connect_ncacn_unix_stream_send(mem_ctx, io);
+       return dcerpc_pipe_connect_ncacn_unix_stream_recv(c);   
+}
+
+
+struct pipe_ncalrpc_state {
+       struct dcerpc_pipe_connect io;
+};
+
+
+void continue_pipe_open_ncalrpc(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+       struct pipe_ncalrpc_state *s = talloc_get_type(c->private_data,
+                                                      struct pipe_ncalrpc_state);
+
+       c->status = dcerpc_pipe_connect_ncalrpc_recv(ctx);
+       if (!NT_STATUS_IS_OK(c->status)) {
+               DEBUG(0,("Failed to open ncalrpc pipe '%s' - %s\n", s->io.binding->endpoint,
+                        nt_errstr(c->status)));
+               composite_error(c, c->status);
+               return;
+       }
+
+       composite_done(c);
+}
+
+
+struct composite_context* dcerpc_pipe_connect_ncalrpc_send(TALLOC_CTX *mem_ctx,
+                                                          struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c;
+       struct pipe_ncalrpc_state *s;
+       struct composite_context *pipe_req;
+
+       /* composite context allocation and setup */
+       c = talloc_zero(mem_ctx, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_ncalrpc_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = io->pipe->conn->event_ctx;
+
+       s->io  = *io;
+
+       pipe_req = dcerpc_pipe_open_pipe_send(s->io.pipe->conn, s->io.binding->endpoint);
+       if (pipe_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       composite_continue(c, pipe_req, continue_pipe_open_ncalrpc, c);
+done:
+       return c;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncalrpc_recv(struct composite_context *c)
+{
+       NTSTATUS status = composite_wait(c);
+       
+       talloc_free(c);
+       return status;
+}
+
+
+NTSTATUS dcerpc_pipe_connect_ncalrpc(TALLOC_CTX *mem_ctx,
+                                    struct dcerpc_pipe_connect *io)
+{
+       struct composite_context *c = dcerpc_pipe_connect_ncalrpc_send(mem_ctx, io);
+       return dcerpc_pipe_connect_ncalrpc_recv(c);
+}
index 75684aaf8a5cdf9f265fc4407af4771656ea3d09..fecbe2254863c04054b49a68d90fb987ae3c3c80 100644 (file)
@@ -348,70 +348,304 @@ NTSTATUS dcerpc_pipe_open_socket(struct dcerpc_connection *conn,
 }
 
 
-/* 
-   open a rpc connection using tcp
-*/
-NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *c, const char *server, uint32_t port)
-{
-       NTSTATUS status;
+struct pipe_tcp_state {
+       const char *server;
+       uint32_t port;
        struct socket_address *srvaddr;
+       struct dcerpc_connection *conn;
+};
 
-       srvaddr = socket_address_from_strings(c, "ipv6", server, port);
-       if (!srvaddr) {
-               return NT_STATUS_NO_MEMORY;
+
+void continue_ipv6_open_socket(struct composite_context *ctx);
+void continue_ipv4_open_socket(struct composite_context *ctx);
+
+
+void continue_ipv6_open_socket(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+       struct pipe_tcp_state *s = talloc_get_type(c->private_data,
+                                                  struct pipe_tcp_state);
+       struct composite_context *sock_ipv4_req;
+
+       c->status = dcerpc_pipe_open_socket_recv(ctx);
+       if (NT_STATUS_IS_OK(c->status)) return;
+
+       talloc_free(s->srvaddr);
+
+       s->srvaddr = socket_address_from_strings(s->conn, "ipv4", s->server, s->port);
+       if (!s->srvaddr) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               return;
        }
        
-       /* Try IPv6 first */
-       status = dcerpc_pipe_open_socket(c, srvaddr, NCACN_IP_TCP);
-       if (NT_STATUS_IS_OK(status)) {
-               return status;
+       /* Try IPv4 if IPv6 fails */
+       sock_ipv4_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
+       if (sock_ipv4_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               return;
        }
 
-       talloc_free(srvaddr);
-       srvaddr = socket_address_from_strings(c, "ipv4", server, port);
-       if (!srvaddr) {
-               return NT_STATUS_NO_MEMORY;
+       composite_continue(c, sock_ipv4_req, continue_ipv4_open_socket, c);
+}
+
+
+void continue_ipv4_open_socket(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+       struct pipe_tcp_state *s = talloc_get_type(c->private_data,
+                                                  struct pipe_tcp_state);
+
+       c->status = dcerpc_pipe_open_socket_recv(ctx);
+       if (NT_STATUS_IS_OK(c->status)) {
+               composite_done(c);
+               return;
        }
+
+       DEBUG(0, ("Failed to connect host %s on port %d - %s.\n",
+                 s->server, s->port, nt_errstr(c->status)));
+
+       composite_error(c, c->status);
+}
+
+
+struct composite_context* dcerpc_pipe_open_tcp_send(struct dcerpc_connection *conn,
+                                                   const char* server, uint32_t port)
+{
+       struct composite_context *c;
+       struct composite_context *sock_ipv6_req;
+       struct pipe_tcp_state *s;
+
+       /* composite context allocation and setup */
+       c = talloc_zero(conn, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_tcp_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = conn->event_ctx;
+
+       s->server = talloc_strdup(c, server);
+       s->port   = port;
+       s->conn   = conn;
        
-       return dcerpc_pipe_open_socket(c, srvaddr, NCACN_IP_TCP);
+       s->srvaddr = socket_address_from_strings(s->conn, "ipv6", s->server, s->port);
+       if (!s->srvaddr) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       /* Try IPv6 first */
+       sock_ipv6_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCACN_IP_TCP);
+       if (sock_ipv6_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       composite_continue(c, sock_ipv6_req, continue_ipv6_open_socket, c);
+done:
+       return c;
 }
 
+
+NTSTATUS dcerpc_pipe_open_tcp_recv(struct composite_context *c)
+{
+       NTSTATUS status;
+       status = composite_wait(c);
+
+       talloc_free(c);
+       return status;
+}
+
+
 /* 
-   open a rpc connection to a unix socket 
+   open a rpc connection using tcp - sync version
 */
-NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *c, const char *path)
+NTSTATUS dcerpc_pipe_open_tcp(struct dcerpc_connection *conn, const char *server,
+                             uint32_t port)
 {
+       struct composite_context *c;
+
+       c = dcerpc_pipe_open_tcp_send(conn, server, port);
+       return dcerpc_pipe_open_tcp_recv(c);
+}
+
+
+struct pipe_unix_state {
+       const char *path;
        struct socket_address *srvaddr;
+       struct dcerpc_connection *conn;
+};
 
-       srvaddr = socket_address_from_strings(c, "unix", path, 0);
-       if (!srvaddr) {
-               return NT_STATUS_NO_MEMORY;
+
+void continue_unix_open_socket(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+
+       c->status = dcerpc_pipe_open_socket_recv(ctx);
+       if (NT_STATUS_IS_OK(c->status)) {
+               composite_done(c);
+               return;
        }
 
-       return dcerpc_pipe_open_socket(c, srvaddr, NCALRPC);
+       composite_error(c, c->status);
 }
 
+
+struct composite_context *dcerpc_pipe_open_unix_stream_send(struct dcerpc_connection *conn,
+                                                           const char *path)
+{
+       struct composite_context *c;
+       struct composite_context *sock_unix_req;
+       struct pipe_unix_state *s;
+
+       /* composite context allocation and setup */
+       c = talloc_zero(conn, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_unix_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = conn->event_ctx;
+
+       s->path = talloc_strdup(c, path);
+       s->conn = conn;
+
+       s->srvaddr = socket_address_from_strings(conn, "unix", s->path, 0);
+       if (s->srvaddr == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+       
+       sock_unix_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
+       if (sock_unix_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       composite_continue(c, sock_unix_req, continue_unix_open_socket, c);
+
+done:
+       return c;
+}
+
+
+NTSTATUS dcerpc_pipe_open_unix_stream_recv(struct composite_context *c)
+{
+       NTSTATUS status = composite_wait(c);
+
+       talloc_free(c);
+       return status;
+}
+
+
 /* 
-   open a rpc connection to a named pipe 
+   open a rpc connection to a unix socket - sync version
 */
-NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *c, const char *identifier)
+NTSTATUS dcerpc_pipe_open_unix_stream(struct dcerpc_connection *conn, const char *path)
 {
-       NTSTATUS status;
-       char *canon, *full_path;
+       struct composite_context *c = dcerpc_pipe_open_unix_stream_send(conn, path);
+       return dcerpc_pipe_open_unix_stream_recv(c);
+}
+
+
+struct pipe_np_state {
+       char *full_path;
        struct socket_address *srvaddr;
+       struct dcerpc_connection *conn;
+};
+
+
+void continue_np_open_socket(struct composite_context *ctx)
+{
+       struct composite_context *c = talloc_get_type(ctx->async.private_data,
+                                                     struct composite_context);
+
+       c->status = dcerpc_pipe_open_socket_recv(ctx);
+       if (NT_STATUS_IS_OK(c->status)) {
+               composite_done(c);
+               return;
+       }
+       
+       composite_error(c, c->status);
+}
+
+
+struct composite_context* dcerpc_pipe_open_pipe_send(struct dcerpc_connection *conn,
+                                                    const char *identifier)
+{
+       char *canon;
+
+       struct composite_context *c;
+       struct composite_context *sock_np_req;
+       struct pipe_np_state *s;
 
-       canon = talloc_strdup(NULL, identifier);
+       /* composite context allocation and setup */
+       c = talloc_zero(conn, struct composite_context);
+       if (c == NULL) return NULL;
+
+       s = talloc_zero(c, struct pipe_np_state);
+       if (s == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       c->state = COMPOSITE_STATE_IN_PROGRESS;
+       c->private_data = s;
+       c->event_ctx = conn->event_ctx;
+
+       canon = talloc_strdup(c, identifier);
+       s->conn = conn;
 
        string_replace(canon, '/', '\\');
-       full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
+       s->full_path = talloc_asprintf(canon, "%s/%s", lp_ncalrpc_dir(), canon);
 
-       srvaddr = socket_address_from_strings(c, "unix", full_path, 0);
-       if (!srvaddr) {
-               return NT_STATUS_NO_MEMORY;
+       s->srvaddr = socket_address_from_strings(conn, "unix", s->full_path, 0);
+       if (s->srvaddr == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
+       }
+
+       sock_np_req = dcerpc_pipe_open_socket_send(c, s->conn, s->srvaddr, NCALRPC);
+       if (sock_np_req == NULL) {
+               composite_error(c, NT_STATUS_NO_MEMORY);
+               goto done;
        }
 
-       status = dcerpc_pipe_open_socket(c, srvaddr, NCALRPC);
+       composite_continue(c, sock_np_req, continue_np_open_socket, c);
+
+done:
        talloc_free(canon);
+       return c;
+}
+
 
+NTSTATUS dcerpc_pipe_open_pipe_recv(struct composite_context *c)
+{
+       NTSTATUS status = composite_wait(c);
+       
+       talloc_free(c);
        return status;
 }
+
+
+/* 
+   open a rpc connection to a named pipe - sync version
+*/
+NTSTATUS dcerpc_pipe_open_pipe(struct dcerpc_connection *conn, const char *identifier)
+{
+       struct composite_context *c = dcerpc_pipe_open_pipe_send(conn, identifier);
+       return dcerpc_pipe_open_pipe_recv(c);
+}
index 6ef91b87b0e3f0aaea4c87ea5ac233a0a292d2b7..011ed9d81e1c975f8da2a377622b7ba2d939c3c9 100644 (file)
@@ -956,75 +956,6 @@ static NTSTATUS dcerpc_pipe_connect_ncacn_np(TALLOC_CTX *tmp_ctx,
 }
 
 
-/* open a rpc connection to a rpc pipe on SMP using the binding
-   structure to determine the endpoint and options */
-static NTSTATUS dcerpc_pipe_connect_ncalrpc(TALLOC_CTX *tmp_ctx, 
-                                           struct dcerpc_pipe *p, 
-                                           struct dcerpc_binding *binding,
-                                               const struct dcerpc_interface_table *table)
-{
-       NTSTATUS status;
-
-       status = dcerpc_pipe_open_pipe(p->conn, binding->endpoint);
-       if (!NT_STATUS_IS_OK(status)) {
-               DEBUG(0,("Failed to open ncalrpc pipe '%s' - %s\n", 
-                        binding->endpoint, nt_errstr(status)));
-               return status;
-       }
-
-       return status;
-}
-
-
-
-/* open a rpc connection to a rpc pipe on SMP using the binding
-   structure to determine the endpoint and options */
-static NTSTATUS dcerpc_pipe_connect_ncacn_unix_stream(TALLOC_CTX *tmp_ctx, 
-                                                     struct dcerpc_pipe *p, 
-                                                     struct dcerpc_binding *binding,
-                                                         const struct dcerpc_interface_table *table)
-{
-       NTSTATUS status;
-
-       if (!binding->endpoint) {
-               DEBUG(0, ("Path to unix socket not specified\n"));
-               return NT_STATUS_INVALID_PARAMETER;
-       }
-
-       status = dcerpc_pipe_open_unix_stream(p->conn, binding->endpoint);
-       if (!NT_STATUS_IS_OK(status)) {
-               DEBUG(0,("Failed to open unix socket %s - %s\n", 
-                        binding->endpoint, nt_errstr(status)));
-               talloc_free(p);
-        return status;
-       }
-
-       return status;
-}
-
-/* open a rpc connection to a rpc pipe on TCP/IP sockets using the binding
-   structure to determine the endpoint and options */
-static NTSTATUS dcerpc_pipe_connect_ncacn_ip_tcp(TALLOC_CTX *tmp_ctx, 
-                                                struct dcerpc_pipe *p, 
-                                                struct dcerpc_binding *binding,
-                                                const struct dcerpc_interface_table *table)
-{
-       NTSTATUS status;
-       uint32_t port = 0;
-
-       port = atoi(binding->endpoint);
-
-       status = dcerpc_pipe_open_tcp(p->conn, binding->host, port);
-       if (!NT_STATUS_IS_OK(status)) {
-               DEBUG(0,("Failed to connect to %s:%d - %s\n", 
-                        binding->host, port, nt_errstr(status)));
-                return status;
-        }
-
-        return status;
-}
-
-
 /* open a rpc connection to a rpc pipe, using the specified 
    binding structure to determine the endpoint and options */
 NTSTATUS dcerpc_pipe_connect_b(TALLOC_CTX *parent_ctx, 
@@ -1082,17 +1013,17 @@ NTSTATUS dcerpc_pipe_connect_b(TALLOC_CTX *parent_ctx,
                break;
 
        case NCACN_IP_TCP:
-               status = dcerpc_pipe_connect_ncacn_ip_tcp(tmp_ctx, 
-                                                         p, binding, table);
+               status = dcerpc_pipe_connect_ncacn_ip_tcp(tmp_ctx, &pc);
                break;
+
        case NCACN_UNIX_STREAM:
-               status = dcerpc_pipe_connect_ncacn_unix_stream(tmp_ctx, 
-                                                              p, binding, table);
+               status = dcerpc_pipe_connect_ncacn_unix_stream(tmp_ctx, &pc);
                break;
+
        case NCALRPC:
-               status = dcerpc_pipe_connect_ncalrpc(tmp_ctx, 
-                                                    p, binding, table);
+               status = dcerpc_pipe_connect_ncalrpc(tmp_ctx, &pc);
                break;
+
        default:
                return NT_STATUS_NOT_SUPPORTED;
        }