cms_srv.cc

Source code for an Numeric Cmputer

    }

    return (remote_port->accept_local_port_cms(_cms));
}

CMS_SERVER_LOCAL_PORT *CMS_SERVER::find_local_port(long _buffer_number)
{
    CMS_SERVER_LOCAL_PORT *cms_local_port;
    cms_local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_head();
    while (NULL != cms_local_port) {
	if (cms_local_port->buffer_number == _buffer_number) {
	    break;
	}
	cms_local_port =
	    (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_next();
    }
    return (cms_local_port);
}

int CMS_SERVER::get_total_subdivisions(long _buffer_number)
{
    CMS_SERVER_LOCAL_PORT *cms_local_port = find_local_port(_buffer_number);
    if (NULL == cms_local_port) {
	return 1;
    }
    if (NULL == cms_local_port->cms) {
	return 1;
    }
    return cms_local_port->cms->total_subdivisions;
}

void CMS_SERVER::set_diag_info(REMOTE_SET_DIAG_INFO_REQUEST * _diag_info)
{
    diag_enabled = 1;
    CMS_SERVER_LOCAL_PORT *local_port =
	find_local_port(_diag_info->buffer_number);
    if (NULL == local_port) {
	rcs_print_error
	    ("CMS_SERVER: Cannot find local port for buffer number %ld\n",
	    _diag_info->buffer_number);
	return;
    }
    local_port->set_diag_info(_diag_info);
    last_local_port_used = local_port;
}

void CMS_SERVER::reset_diag_info(int buffer_number)
{
    diag_enabled = 0;
    CMS_SERVER_LOCAL_PORT *local_port = find_local_port(buffer_number);
    if (NULL == local_port) {
	rcs_print_error
	    ("CMS_SERVER: Cannot find local port for buffer number %ld\n",
	    buffer_number);
	return;
    }
    local_port->reset_diag_info();
    last_local_port_used = NULL;
}

REMOTE_CMS_REPLY *CMS_SERVER::process_request(REMOTE_CMS_REQUEST * _request)
{
    CMS_SERVER_LOCAL_PORT *local_port;

    requests_processed++;

    request = _request;
    if (NULL == request) {
	rcs_print_error("CMS_SERVER: Request is NULL.\n");
	return NULL;
    }

    local_port = find_local_port(request->buffer_number);
    last_local_port_used = local_port;
    if (NULL == local_port) {
	rcs_print_error
	    ("CMS_SERVER: Cannot find local port for buffer number %ld\n",
	    request->buffer_number);
	return (NULL);
    }
    if (!security_check
	(remote_port->current_user_info, request->buffer_number)) {
	return NULL;
    }

    local_port->cms->set_subdivision(_request->subdiv);
    _request->subdiv = 0;

    switch (request->type) {
    case REMOTE_CMS_GET_BUF_NAME_REQUEST_TYPE:
	{
	    REMOTE_GET_BUF_NAME_REPLY *namereply = &local_port->namereply;
	    const char *name = get_buffer_name(request->buffer_number);
	    if (0 == name) {
		return NULL;
	    }
	    strncpy(namereply->name, name, 31);
	    return namereply;
	}

    case REMOTE_CMS_READ_REQUEST_TYPE:
	return (local_port->reader((REMOTE_READ_REQUEST *) request));
    case REMOTE_CMS_GET_DIAG_INFO_REQUEST_TYPE:
	return (local_port->get_diag_info
	    ((REMOTE_GET_DIAG_INFO_REQUEST *) request));
    case REMOTE_CMS_BLOCKING_READ_REQUEST_TYPE:
	return (local_port->blocking_read((REMOTE_READ_REQUEST *) request));
    case REMOTE_CMS_WRITE_REQUEST_TYPE:
	return (local_port->writer((REMOTE_WRITE_REQUEST *) request));
    case REMOTE_CMS_CHECK_IF_READ_REQUEST_TYPE:
	if (NULL == local_port->cms) {
	    rcs_print_error
		("CMS_SERVER: cms object associated with local port is NULL.\n");
	    return (NULL);
	}
	cir_reply.was_read = local_port->cms->check_if_read();
	cir_reply.status = local_port->cms->status;
	return (&cir_reply);

    case REMOTE_CMS_GET_MSG_COUNT_REQUEST_TYPE:
	if (NULL == local_port->cms) {
	    rcs_print_error
		("CMS_SERVER: cms object associated with local port is NULL.\n");
	    return (NULL);
	}
	gmc_reply.count = local_port->cms->get_msg_count();
	gmc_reply.status = local_port->cms->status;
	return (&gmc_reply);

    case REMOTE_CMS_GET_QUEUE_LENGTH_REQUEST_TYPE:
	if (NULL == local_port->cms) {
	    rcs_print_error
		("CMS_SERVER: cms object associated with local port is NULL.\n");
	    return (NULL);
	}
	gql_reply.queue_length = local_port->cms->get_queue_length();
	gql_reply.status = local_port->cms->status;
	return (&gql_reply);

    case REMOTE_CMS_GET_SPACE_AVAILABLE_REQUEST_TYPE:
	if (NULL == local_port->cms) {
	    rcs_print_error
		("CMS_SERVER: cms object associated with local port is NULL.\n");
	    return (NULL);
	}
	gsa_reply.space_available = local_port->cms->get_space_available();
	gsa_reply.status = local_port->cms->status;
	return (&gsa_reply);

    case REMOTE_CMS_CLEAR_REQUEST_TYPE:
	if (NULL == local_port->cms) {
	    rcs_print_error
		("CMS_SERVER: cms object associated with local port is NULL.\n");
	    return (NULL);
	}
	local_port->cms->clear();
	clear_reply_struct.status = local_port->cms->status;
	return (&clear_reply_struct);
/*! \todo Another #if 0 */
#if 0
    case REMOTE_CMS_GET_KEYS_REQUEST_TYPE:
	get_keys_reply = &perm_get_keys_reply;
	get_user_keys(
	    ((REMOTE_GET_KEYS_REQUEST *) request)->name,
	    get_keys_reply->key1, get_keys_reply->key2);
	return (&perm_get_keys_reply);
#endif
    case REMOTE_CMS_LOGIN_REQUEST_TYPE:
	login_reply = &perm_login_reply;
	if (NULL == remote_port->current_connected_user_struct) {
	    login_reply->success = 0;
	    return (&perm_login_reply);
	}
	remote_port->current_connected_user_struct->user_info =
	    get_user_info(
	    ((REMOTE_LOGIN_REQUEST *) request)->name,
	    ((REMOTE_LOGIN_REQUEST *) request)->passwd);
	login_reply->success =
	    (NULL != remote_port->current_connected_user_struct->user_info);
	if (login_reply->success) {
	    rcs_print("%s logged in.\n",
		remote_port->current_connected_user_struct->user_info->name);
	}
	return (&perm_login_reply);

    case REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE:
	set_subscription_reply = &perm_set_subscription_reply;
	set_subscription_reply->success = 1;
	return (&perm_set_subscription_reply);

    default:
	rcs_print_error("CMS_SERVER: Invalid request type (%d)\n",
	    request->type);
	return (NULL);
    }
}

/* Spawning Routine. */
int CMS_SERVER::spawn()
{
    if (0 == server_spawned) {
	if (NULL != remote_port) {
	    remote_port->running = 0;
	}
	server_spawned = 1;
	current_pid = spawner_pid = getpid();
	if (0 == (server_pid = fork())) {
	    /* Child */
	    run();		/* This will only return if an error occurs. */
	    clean(2);
	    exit(-1);
	} else {
	    /* Parent */
	}
	int waits = 0;
	while (waits < 20) {
	    esleep(0.01);
	    if (NULL == remote_port) {
		break;
	    }
	    if (remote_port->running) {
		break;
	    }
	    waits++;
	}
	return 1;
    }
    return 0;
}

void CMS_SERVER::kill_server()
{
    if (0 != server_pid) {
	signal(SIGINT, SIG_DFL);
	cms_server_count--;
	kill(server_pid, SIGINT);
	waitpid(server_pid, NULL, 0);
	server_pid = 0;
    }
}

/* MAIN ROUTINE */
void CMS_SERVER::register_server(int setup_CC_signal_local_port)
{
    last_local_port_used = NULL;
    server_registered = 1;

    if (NULL == cms_server_list) {
	cms_server_list = new LinkedList;
    }
    list_id = cms_server_list->store_at_tail(this, sizeof(CMS_SERVER), 0);

    /* Set up interrupt local_port. */
    if (setup_CC_signal_local_port) {
	signal(SIGINT, clean);	/* Set up interrupt local_port. */
    }

    if (NULL == remote_port) {
	rcs_print_error
	    ("CMS_SERVER: Can't register with NULL remote port.\n");
	return;
    }
    remote_port->register_port();

}

void CMS_SERVER::run(int setup_CC_signal_local_port)
{
    server_tid = current_tid = 0;
    current_pid = server_pid = getpid();
    if (!server_registered) {
	register_server(setup_CC_signal_local_port);
    }
    initialize_write_request_space();
    if (NULL == remote_port) {
	rcs_print_error
	    ("CMS_SERVER: Cannot run with remote port equal to NULL.\n");
	return;
    }
    remote_port->running = 1;
    if (remote_port->port_registered) {
	remote_port->run();
    }
}

void CMS_SERVER::initialize_write_request_space()
{
    max_total_subdivisions = 1;
    maximum_cms_size = 0;
    CMS_SERVER_LOCAL_PORT *local_port;
    if (NULL == cms_local_ports) {
	rcs_print_error
	    ("CMS_SERVER: Can not search list of local ports to determine the size of space needed for the write request\n"
	    "because the list is NULL.\n");
	return;
    }
    local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_head();
    while (NULL != local_port) {
	if (NULL != local_port->cms) {
	    if (local_port->cms->size > maximum_cms_size) {
		maximum_cms_size = local_port->cms->size;
	    }
	    if (local_port->cms->total_subdivisions > max_total_subdivisions) {
		max_total_subdivisions = local_port->cms->total_subdivisions;
	    }
	    if (NULL != remote_port) {
		if (local_port->cms->total_subdivisions >
		    remote_port->max_total_subdivisions) {
		    remote_port->max_total_subdivisions =
			local_port->cms->total_subdivisions;
		}
	    }
	    if (local_port->cms->max_encoded_message_size > maximum_cms_size) {
		maximum_cms_size = local_port->cms->max_encoded_message_size;
	    }
	}
	local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_next();
    }
    if (NULL != write_req.data) {
	free(write_req.data);
	write_req.data = NULL;
    }
    write_req.data = malloc(maximum_cms_size);
    if (NULL == write_req.data) {
	rcs_print_error("malloc(%d) failed.\n", maximum_cms_size);
    }
    local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_head();
    while (NULL != local_port) {
	if (NULL != local_port->cms) {
	    local_port->cms->set_encoded_data(write_req.data,
		maximum_cms_size);
	}
	local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_next();
    }
}

CMS_SERVER::CMS_SERVER()
{
    last_local_port_used = NULL;
    diag_enabled = 0;
    using_passwd_file = 0;
    current_pid = 0;
    server_pid = 0;
    spawner_pid = 0;
    server_registered = 0;
    guest_can_read = 0;
    guest_can_write = 0;
    server_spawned = 0;
    list_id = 0;
    requests_processed = 0;
    read_reply = NULL;
    write_reply = NULL;
    check_if_read_reply = NULL;
    clear_reply = NULL;
    remote_port = NULL;
    request = NULL;
    write_req.data = NULL;
    cms_local_ports = new LinkedList;
    known_users = NULL;
    max_total_subdivisions = 1;
    memset(passwd_file, 0, 256);
    creator_pid = getpid();
}

CMS_SERVER::~CMS_SERVER()
{
    last_local_port_used = NULL;
    if (server_registered && (!server_spawned || current_pid == server_pid)) {
	unregister_server();
    } else if (server_spawned && current_pid == spawner_pid) {
	kill_server();
    }
    delete_all_local_ports();
    if (NULL != remote_port) {
	delete remote_port;
	remote_port = NULL;
    }
    if (NULL != cms_local_ports) {
	delete cms_local_ports;
	cms_local_ports = NULL;
    }
    // Leave this to NML_SERVER destructor.
    // delete_from_list();

    if (NULL != write_req.data) {
	free(write_req.data);
	write_req.data = NULL;
    }
}

void CMS_SERVER::delete_all_local_ports()
{
    if (NULL != cms_local_ports) {
	CMS_SERVER_LOCAL_PORT *local_port;
	local_port = (CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_head();
	while (NULL != local_port) {
	    delete local_port;
	    cms_local_ports->delete_current_node();
	    local_port =
		(CMS_SERVER_LOCAL_PORT *) cms_local_ports->get_next();
	}
    }
}

static int last_cms_server_signum = 0;

void CMS_SERVER::clean(int signum)
{
    last_cms_server_signum = signum;
    pid_t current_pid;
    pid_t current_tid = 0;
    current_pid = getpid();
    CMS_SERVER *cms_server = NULL;

    cms_server = (CMS_SERVER *) cms_server_list->get_head();
    while (NULL != cms_server) {
	if (cms_server->server_pid == current_pid
	    && cms_server->server_tid == current_tid) {
	    cms_server->unregister_server();
	    delete cms_server;
	    cms_server = NULL;
	}
	cms_server = (CMS_SERVER *) cms_server_list->get_next();
    }

    exit(0);
}

void CMS_SERVER::unregister_server()
{
    if (server_registered) {
	server_registered = 0;
	if (NULL != remote_port) {
	    remote_port->unregister_port();
	}
    }
}

void CMS_SERVER::delete_from_list()
{
    current_pid = getpid();
    current_tid = 0;

    if (current_pid == server_pid && current_tid == server_tid) {
	if (NULL != cms_server_list && list_id > 0) {
	    cms_server_list->delete_node(list_id);
	    list_id = -1;
	}
    }
}

const char *CMS_SERVER::get_buffer_name(int buffer_number)
{
    CMS_SERVER_LOCAL_PORT *local_port;
    local_port = find_local_port(buffer_number);
    if (NULL == local_port) {
	return NULL;
    }
    return (const char *) local_port->cms->BufferName;
}

long CMS_SERVER::get_message_type()
{
    return -1;
    // I need to be overloaded.
}

int CMS_SERVER::get_access_type()
{
    if (NULL == request) {
	return -1;
    }
    return request->type;
}

int CMS_SERVER::security_check(CMS_USER_INFO * user_info, int buffer_number)
{
    CMS_SERVER_LOCAL_PORT *local_port;
    local_port = find_local_port(buffer_number);
    if (!using_passwd_file) {
	return 1;
    }
    if (request->type == REMOTE_CMS_GET_KEYS_REQUEST_TYPE ||
	request->type == REMOTE_CMS_LOGIN_REQUEST_TYPE) {
	return 1;
    }

    if (NULL == user_info) {

	if (guest_can_read && (request->type == REMOTE_CMS_READ_REQUEST_TYPE
		|| request->type ==
		REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE)) {
	    return 1;
	}

	if (guest_can_write && request->type == REMOTE_CMS_WRITE_REQUEST_TYPE) {
	    return 1;
	}
	rcs_print_error
	    ("CMS_SERVER: Refusing to process request of unknown user.\n");
	return 0;
    }

    if (user_info->allow_read
	&& (request->type == REMOTE_CMS_READ_REQUEST_TYPE
	    || request->type == REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE)) {
	return 1;
    }

    if (user_info->allow_write
	&& request->type == REMOTE_CMS_WRITE_REQUEST_TYPE) {
	return 1;
    }

    if (NULL != detailed_security_check) {
	return detailed_security_check(user_info->name,
	    get_buffer_name(buffer_number),
	    get_message_type(), get_access_type());
    }

    if (!user_info->allow_read
	&& request->type == REMOTE_CMS_READ_REQUEST_TYPE) {
	rcs_print_error("CMS_SERVER:: %s does not have read permission.");
	return 0;
    }

    if (!user_info->allow_write
	&& request->type == REMOTE_CMS_WRITE_REQUEST_TYPE) {
	rcs_print_error("CMS_SERVER:: %s does not have write permission.");
	return 0;
    }
    return 1;

}

int (*detailed_security_check) (const char *user_name,
    const char *buffer_name, long msg_type, int access_type) = NULL;