NTSTATUS create_conn_struct_cwd(TALLOC_CTX *ctx,
				struct tevent_context *ev,
				struct messaging_context *msg,
				connection_struct **pconn,
				int snum,
				const char *path,
				const struct auth_session_info *session_info,
				char **poldcwd)
{
	connection_struct *conn;
	char *oldcwd;

	NTSTATUS status = create_conn_struct(ctx, ev,
					     msg, &conn,
					     snum, path,
					     session_info);
	if (!NT_STATUS_IS_OK(status)) {
		return status;
	}

	/*
	 * Windows seems to insist on doing trans2getdfsreferral() calls on
	 * the IPC$ share as the anonymous user. If we try to chdir as that
	 * user we will fail.... WTF ? JRA.
	 */

	oldcwd = vfs_GetWd(ctx, conn);
	if (oldcwd == NULL) {
		status = map_nt_error_from_unix(errno);
		DEBUG(3, ("vfs_GetWd failed: %s\n", strerror(errno)));
		conn_free(conn);
		return status;
	}

	if (vfs_ChDir(conn,conn->connectpath) != 0) {
		status = map_nt_error_from_unix(errno);
		DEBUG(3,("create_conn_struct: Can't ChDir to new conn path %s. "
			"Error was %s\n",
			conn->connectpath, strerror(errno) ));
		conn_free(conn);
		return status;
	}

	*pconn = conn;
	*poldcwd = oldcwd;

	return NT_STATUS_OK;
}

static void queue_free(Queue *q)
{
    for (List *it = q->head; it != NULL; it = list_next(it))
        conn_free(it->elem);
    mon_free(q->mon);
    mem_free(q);
}

int slave(context_t* ctx) {
	hlink_t*	hardlinks = NULL;	// The hardlinks we found while performing SCAN
	conn_t cn;

	// Config
	(void)ctx;
	conn_init(&cn);
	cn.infd = 0;
	cn.outfd = 1;

	// Main
	char line[1024];

	ssize_t l;
	while((l = conn_readline(&cn, line, sizeof line))) {
		proto_delegator(&cn,line,&hardlinks);
	}

	// close down
	conn_free(&cn);

	// Free hardlinks
	hlink_t* n = NULL;
	hlink_t* p;
	for(p = hardlinks; p; p = n) {
		n = (hlink_t*)((node_t*)p)->next;
		free(p);
	}
	hardlinks = NULL;

	return 0;
}

static struct connection *conn_create_server(struct context *ctx,
        struct address *addr, char *key, bool readonly)
{
    int fd = conn_create_fd();
    if (fd == -1) {
        LOG(ERROR, "conn_create_server: fail to create fd");
        return NULL;
    }
    struct connection *server = server_create(ctx, fd);
    struct conn_info *info = server->info;
    memcpy(&info->addr, addr, sizeof(info->addr));
    extern const size_t CMD_NUM;
    info->slow_cmd_counts = cv_calloc(CMD_NUM, sizeof(uint32_t));

    if (conn_connect(server) == CORVUS_ERR) {
        LOG(ERROR, "conn_create_server: fail to connect %s:%d",
                info->addr.ip, info->addr.port);
        conn_free(server);
        conn_buf_free(server);
        conn_recycle(ctx, server);
        return NULL;
    }

    if (readonly) {
        server->info->readonly = true;
    }

    strncpy(info->dsn, key, ADDRESS_LEN);
    dict_set(&ctx->server_table, info->dsn, (void*)server);
    TAILQ_INSERT_TAIL(&ctx->servers, server, next);
    return server;
}

connection_struct *make_connection_smb2(struct smbd_smb2_request *req,
					struct smbXsrv_tcon *tcon,
					int snum,
					struct user_struct *vuser,
					const char *pdev,
					NTSTATUS *pstatus)
{
	struct smbd_server_connection *sconn = req->sconn;
	connection_struct *conn = conn_new(sconn);
	if (!conn) {
		DEBUG(0,("make_connection_smb2: Couldn't find free connection.\n"));
		*pstatus = NT_STATUS_INSUFFICIENT_RESOURCES;
		return NULL;
	}

	conn->cnum = tcon->global->tcon_wire_id;
	conn->tcon = tcon;

	*pstatus = make_connection_snum(req->xconn,
					conn,
					snum,
					vuser,
					pdev);
	if (!NT_STATUS_IS_OK(*pstatus)) {
		conn_free(conn);
		return NULL;
	}
	return conn;
}

/*
 * Get a connection for the specified service and return a pointer
 * to a new connection_s
 */
connection_s *conn_new( struct service *sp )
{
   connection_s    new_conn ;
   connection_s   *cp ;
   const char     *func = "conn_new" ;

   CLEAR( new_conn ) ;

   /*
    * The reason we first get the connection and then allocate a
    * 'connection_s' is because we want to always consume some input.
    */
   if ( get_connection( sp, &new_conn ) == FAILED )
      return( NULL ) ;

   new_conn.co_sp = sp ;
   SVC_HOLD( sp ) ;
   
   if ( SVC_WAITS( sp ) )
      svc_suspend( sp ) ;

   cp = NEW_CONN() ;
   if ( cp == CONN_NULL )
   {
      out_of_memory( func ) ;
      conn_free( &new_conn, 0 ) ;
      CLEAR( new_conn ) ;
      return( CONN_NULL ) ;
   }
   memcpy(cp, &new_conn, sizeof(connection_s));
   return( cp ) ;
}

connection_struct *make_connection_with_chdir(const char *service_in,
					      DATA_BLOB password, 
					      const char *dev, uint16 vuid,
					      NTSTATUS *status)
{
	connection_struct *conn = NULL;
	
	conn = make_connection(service_in, password, dev, vuid, status);
	
	/*
	 * make_connection() does not change the directory for us any more
	 * so we have to do it as a separate step  --jerry
	 */
	 
	if ( conn && vfs_ChDir(conn,conn->connectpath) != 0 ) {
		DEBUG(0,("move_driver_to_download_area: Can't change "
			 "directory to %s for [print$] (%s)\n",
			 conn->connectpath,strerror(errno)));
		yield_connection(conn, lp_servicename(SNUM(conn)));
		conn_free(conn);
		*status = NT_STATUS_UNSUCCESSFUL;
		return NULL;
	}
	
	return conn;
}

void
conn_put(struct conn *conn)
{
    struct conn_base *cb = conn->cb;
    ASSERT(conn->sd < 0);
    ASSERT(conn->owner == NULL);

    log_debug(LOG_VVERB, "put conn %p", conn);

    if (cb == NULL) {
        conn_free(conn);
        return;
    }

    cb->nfree_connq++;
    TAILQ_INSERT_HEAD(&cb->free_connq, conn, conn_tqe);

    if (conn->client) {
        cb->ncurr_cconn--;

        STATS_LOCK();
        ncurr_cconn --;
        STATS_UNLOCK();
    }
    cb->ncurr_conn--;

    STATS_LOCK();
    ncurr_conn --;
    STATS_UNLOCK();
}

void conn_free(struct connection *conn)
{
    if (conn == NULL) return;
    if (conn->fd != -1) {
        close(conn->fd);
        conn->fd = -1;
    }

    conn->registered = false;

    if (conn->ev != NULL) {
        conn->ev->info = NULL;
        conn_free(conn->ev);
        conn_recycle(conn->ctx, conn->ev);
        conn->ev = NULL;
    }

    if (conn->info == NULL) return;
    struct conn_info *info = conn->info;

    info->status = DISCONNECTED;

    reader_free(&info->reader);
    reader_init(&info->reader);

    EMPTY_CMD_QUEUE(&info->cmd_queue, cmd_next);
    EMPTY_CMD_QUEUE(&info->ready_queue, ready_next);
    EMPTY_CMD_QUEUE(&info->waiting_queue, waiting_next);
}

static NTSTATUS fss_vfs_conn_create(TALLOC_CTX *mem_ctx,
				    struct tevent_context *ev,
				    struct messaging_context *msg_ctx,
				    struct auth_session_info *session_info,
				    int snum,
				    struct connection_struct **conn_out)
{
	struct connection_struct *conn = NULL;
	NTSTATUS status;

	status = create_conn_struct(mem_ctx, ev, msg_ctx, &conn,
				    snum, lp_path(mem_ctx, snum),
				    session_info);
	if (!NT_STATUS_IS_OK(status)) {
		DEBUG(0,("failed to create conn for vfs: %s\n",
			 nt_errstr(status)));
		return status;
	}

	status = set_conn_force_user_group(conn, snum);
	if (!NT_STATUS_IS_OK(status)) {
		DEBUG(0, ("failed set force user / group\n"));
		goto err_free_conn;
	}

	*conn_out = conn;

	return NT_STATUS_OK;

err_free_conn:
	SMB_VFS_DISCONNECT(conn);
	conn_free(conn);
	return status;
}

static struct connection *conn_create_server(struct context *ctx, struct address *addr, char *key)
{
    int fd = conn_create_fd();
    if (fd == -1) {
        LOG(ERROR, "conn_create_server: fail to create fd");
        return NULL;
    }
    struct connection *server = server_create(ctx, fd);
    struct conn_info *info = server->info;
    memcpy(&info->addr, addr, sizeof(info->addr));

    if (conn_connect(server) == CORVUS_ERR) {
        LOG(ERROR, "conn_create_server: fail to connect %s:%d",
                info->addr.ip, info->addr.port);
        conn_free(server);
        conn_buf_free(server);
        conn_recycle(ctx, server);
        return NULL;
    }

    strncpy(info->dsn, key, DSN_LEN);
    dict_set(&ctx->server_table, info->dsn, (void*)server);
    TAILQ_INSERT_TAIL(&ctx->servers, server, next);
    return server;
}

void svc_request( struct service *sp )
{
   connection_s *cp ;
   status_e ret_code;

   cp = conn_new( sp ) ;
   if ( cp == CONN_NULL )
      return ;

   /*
    * Output the banner now that the connection is established. The
    * other banners come later.
    */
   banner_always(sp, cp);

   if (SVC_NOT_GENERIC(sp))
      ret_code = spec_service_handler(sp, cp);
   else 
      ret_code = svc_generic_handler(sp, cp);

   if( (SVC_SOCKET_TYPE( sp ) == SOCK_DGRAM) && (SVC_IS_ACTIVE( sp )) ) 
      drain( cp->co_descriptor ) ; /* Prevents looping next time */
   
   if ( ret_code != OK ) 
   {
      if ( SVC_LOGS_USERID_ON_FAILURE( sp ) ) {
         if( spec_service_handler( LOG_SERVICE( ps ), cp ) == FAILED ) 
	    conn_free( cp, 1 ) ;
         else if (!SC_WAITS( SVC_CONF( sp ) ) ) {
	 /* The logging service will gen SIGCHLD thus freeing connection */
	    CONN_CLOSE(cp) ; 
	 }
	 return;
      }
      if (!SC_WAITS( SVC_CONF( sp ) )) 
	 conn_free( cp, 1 );
      else { 
         if( (SVC_SOCKET_TYPE( sp ) == SOCK_DGRAM) && (SVC_IS_ACTIVE( sp )) ) 
            drain( cp->co_descriptor ) ; /* Prevents looping next time */
	 free( cp );
      }
   }
   else if ((SVC_NOT_GENERIC(sp)) || (!SC_FORKS( SVC_CONF( sp ) ) ) )
     free( cp );
}

/**
 * Delete all connections.
 */
void delete_all_connections() {
  /* Delete connections if needed. */
  conn_t *conn, *next;
  for (conn = get_connections(); conn != NULL; conn = next) {
    next = conn->next;
    if (conn->delete_me)
      conn_free(conn);
  }
}

void connmgr_free(struct conn_manager* self)
{
        size_t i;
        for (i = 0; i < connmgr_size(self); i ++) {
                conn_disconnect(self->conns[i]);
                conn_free(self->conns[i]), free(self->conns[i]);
        }
        free(self->conns);
        memset(self, 0, sizeof(*self));
}

void __connmgr_remove_connection_at(struct conn_manager* self, size_t i)
{
        conn_disconnect(self->conns[i]);
        conn_free(self->conns[i]), free(self->conns[i]);
        size_t j;
        for (j = i + 1; j < connmgr_size(self); j ++) {
                self->conns[j - 1] = self->conns[j];
        }
        self->num_conns --;
}

int32 mesh_free(Mesh *mesh)
{
  int32 ii;
  MeshTopology *topology = mesh->topology;
  LocalEntities *entities = mesh->entities;

  for (ii = 0; ii < 16; ii++) {
    conn_free(topology->conn[ii]);
  }

  for (ii = 0; ii < MAX_EL_TYPES; ii++) {
    conn_free(entities->edges[ii]);
    conn_free(entities->faces[ii]);
  }

  free_mem(topology->edge_oris);
  free_mem(topology->face_oris);

  return(RET_OK);
}

void close_cnum(connection_struct *conn, uint16 vuid)
{
	if (IS_IPC(conn)) {
		pipe_close_conn(conn);
	} else {
		file_close_conn(conn);
		dptr_closecnum(conn);
	}

	change_to_root_user();

	DEBUG(IS_IPC(conn)?3:1, ("%s (%s) closed connection to service %s\n",
				 get_remote_machine_name(),
				 conn->client_address,
				 lp_servicename(SNUM(conn))));

	/* Call VFS disconnect hook */    
	SMB_VFS_DISCONNECT(conn);

	yield_connection(conn, lp_servicename(SNUM(conn)));

	/* make sure we leave the directory available for unmount */
	vfs_ChDir(conn, "/");

	/* execute any "postexec = " line */
	if (*lp_postexec(SNUM(conn)) && 
	    change_to_user(conn, vuid))  {
		pstring cmd;
		pstrcpy(cmd,lp_postexec(SNUM(conn)));
		standard_sub_advanced(lp_servicename(SNUM(conn)), conn->user,
				      conn->connectpath, conn->gid,
				      get_current_username(),
				      current_user_info.domain,
				      cmd, sizeof(cmd));
		smbrun(cmd,NULL);
		change_to_root_user();
	}

	change_to_root_user();
	/* execute any "root postexec = " line */
	if (*lp_rootpostexec(SNUM(conn)))  {
		pstring cmd;
		pstrcpy(cmd,lp_rootpostexec(SNUM(conn)));
		standard_sub_advanced(lp_servicename(SNUM(conn)), conn->user,
				      conn->connectpath, conn->gid,
				      get_current_username(),
				      current_user_info.domain,
				      cmd, sizeof(cmd));
		smbrun(cmd,NULL);
	}

	conn_free(conn);
}

int32 mesh_free_connectivity(Mesh *mesh, int32 d1, int32 d2)
{
  uint32 D = mesh->topology->max_dim;
  MeshConnectivity *conn = 0;

  debprintf("free connectivity %d -> %d\n", d1, d2);

  conn = mesh->topology->conn[IJ(D, d1, d2)];
  conn_free(conn);

  return(RET_OK);
}

void
conn_deinit(struct conn_base *cb)
{
    struct conn *conn, *nconn; /* current and next connection */

    for (conn = TAILQ_FIRST(&cb->free_connq); conn != NULL;
            conn = nconn, cb->nfree_connq--) {
        ASSERT(cb->nfree_connq > 0);
        nconn = TAILQ_NEXT(conn, conn_tqe);
        conn_free(conn);
    }
    ASSERT(cb->nfree_connq == 0);
}

void
conn_deinit(void)
{
    struct conn *conn, *nconn; /* current and next connection */

    for (conn = STAILQ_FIRST(&free_connq); conn != NULL;
         conn = nconn, nfree_connq--) {
        ASSERT(nfree_connq > 0);
        nconn = STAILQ_NEXT(conn, conn_tqe);
        conn_free(conn);
    }
    ASSERT(nfree_connq == 0);
}