socket.c

来自「CS架构的多平台的GUI系统」· C语言 代码 · 共 614 行 · 第 1/2 页

			ret = s_socket_listen_event(window, soc);
			break;
		case SOC_DATA_CLOSE:
			ret = s_socket_listen_close(window, soc);
			break;
		case SOC_DATA_EXPOSE:
			ret = s_socket_listen_expose(window, soc);
			break;
		case SOC_DATA_DESKTOP:
			ret = s_socket_listen_desktop(window, soc);
			break;
		case SOC_DATA_NEW:
                case SOC_DATA_HIDE:
		case SOC_DATA_SHOW:
		case SOC_DATA_TITLE:
		case SOC_DATA_STREAM:
		case SOC_DATA_NOTHING:
		case SOC_DATA_DISPLAY:
		case SOC_DATA_FORMDRAW:
		case SOC_DATA_CONFIGURE:
		case SOC_DATA_CONFIGURE_NOFORM:
			break;
	}

        s_thread_mutex_unlock(window->socket_mutex);
	return ret;
err0:	s_thread_mutex_unlock(window->socket_mutex);
	return -1;
}

int s_socket_listen_wait (s_window_t *window, int timeout)
{
        int i;
        int len;
	int ret;
	int retval;
	long long tv[2];
	s_timer_t *tmr;
	s_pollfd_t *pfd;
	struct pollfd *polfd;

	if (window->running <= 0) {
		return -1;
	}

	s_thread_mutex_lock(window->pollfds->mut);
	len = window->pollfds->list->nb_elt;
        polfd = (struct pollfd *) s_malloc(len * sizeof(struct pollfd));
        for (i = 0; i < len; i++) {
		pfd = (s_pollfd_t *) s_list_get(window->pollfds->list, i);
		polfd[i].fd = pfd->fd;
		polfd[i].events = POLLIN;
		polfd[i].revents = 0;
	}
	s_thread_mutex_unlock(window->pollfds->mut);

	timeout = -1;
	i = 0;
	s_thread_mutex_lock(window->timers->mut);
	while (!s_list_eol(window->timers->timers, i)) {
		tmr = (s_timer_t *) s_list_get(window->timers->timers, i);
		if (tmr->timeval > 0) {
			if (timeout <= 0) {
				timeout = tmr->timeval;
			}
			if (tmr->timeval < timeout) {
				timeout = tmr->timeval;
			}
			if (tmr->interval <= 0) {
				tmr->interval = tmr->timeval;
			}
		} else {
			s_list_remove(window->timers->timers, i);
			continue;
		}
		i++;
	}
	s_thread_mutex_unlock(window->timers->mut);

	tv[0] = s_gettimeofday();
	ret = s_socket_api_poll(polfd, len, timeout);
	tv[1] = s_gettimeofday();

	retval = 0;
	switch (ret) {
		case 0:
			goto end;
		case -1:
			retval = -1;
			goto end;
		default :
			for (i = 0; i < len; i++) {
				pfd = s_pollfd_find(window, polfd[i].fd);
				if (polfd[i].revents & (POLLHUP | POLLERR | POLLNVAL)) {
err:					if (pfd->pf_err != NULL) {
						retval = pfd->pf_err(window, polfd[i].fd);
						goto end;
					}
				} else if (polfd[i].revents == POLLIN) {
					if (pfd->pf_in != NULL) {
						if ((retval = pfd->pf_in(window, polfd[i].fd)) < 0) {
							debugf(DSER, "pfd->in(window, polfd[%d].fd) < 0) Calling pfd->ierr if exists", i);
							goto err;
						}
						goto end;
					}
				}
			}
	}

end:	i = 0;
	s_thread_mutex_lock(window->timers->mut);
	while (!s_list_eol(window->timers->timers, i)) {
		tmr = (s_timer_t *) s_list_get(window->timers->timers, i);
		tmr->interval -= (tv[1] - tv[0]);
		i++;
	}
	i = 0;
	while (!s_list_eol(window->timers->timers, i)) {
		tmr = (s_timer_t *) s_list_get(window->timers->timers, i);
		if (tmr->interval <= 0) {
			s_event_t *e;
			s_event_init(&e);
			e->type = TIMER_EVENT;
			e->timer = tmr;
			s_eventq_add(window, e);
		}
		i++;
	}
	s_thread_mutex_unlock(window->timers->mut);

	s_free(polfd);
	return retval;
}

int s_socket_uninit (s_window_t *window, int s)
{
	s_thread_mutex_destroy(window->socket_mutex);
	s_socket_api_close(s);
	return 0;
}

int s_socket_in_f (s_window_t *window, int s)
{
	return s_socket_listen_parse(window, s);
}

int s_socket_ierr_f (s_window_t *window, int s)
{
	debugf(DCLI, "[%d] Server side closed the connection", window->client->id);
	return -1;
}

int s_socket_inw_f (s_window_t *window, int s)
{
        int w;
	s_pipe_api_read(s, &w, sizeof(int));
	return 0;
}

int s_socket_ierrw_f (s_window_t *window, int s)
{
	return -1;
}

int s_socket_api_closew_f (s_window_t *window, int s)
{
	s_pipe_api_close(s);
	s_pipe_api_close(window->wsoc);
	return 0;
}

int s_socket_init_uds (s_window_t *window)
{
#if defined(IPC_UDS)
	int fd;
        struct sockaddr_un server = {AF_UNIX, S_SERVER_SOC_NAME};

	fd = s_socket_api_socket(AF_UNIX, SOCK_STREAM, 0);
        if (fd < 0) {
		goto err0;
	}
	if (s_socket_api_connect(fd, (s_sockaddr_t *) &server, sizeof(server)) == -1) {
		goto err1;
	}
	debugf(DCLI, "Connected to server via UDS (%s)", S_SERVER_SOC_NAME);
	return fd;

err1:	s_socket_api_close(fd);
err0:	return -1;
#else
	return -1;
#endif
}

int s_socket_init_tcp (s_window_t *window)
{
#if defined(IPC_TCP)
        int fd;
	struct sockaddr_in server;
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = inet_addr(S_SERVER_SOC_ADDR);
	server.sin_port = htons(S_SERVER_SOC_PORT);

        fd = s_socket_api_socket(AF_INET, SOCK_STREAM, 0);
        if (fd < 0) {
		goto err0;
	}
	if (s_socket_api_connect(fd, (s_sockaddr_t *) &server, sizeof(server)) == -1) {
		goto err1;
	}
	debugf(DCLI, "Connected to server via TCP (%s:%d)", S_SERVER_SOC_ADDR, S_SERVER_SOC_PORT);
	return fd;
err1:	s_socket_api_close(fd);
err0:	return -1;
#else
	return -1;
#endif
}

int s_socket_init_pipe (s_window_t *window)
{
#if defined(IPC_PIPE)
	int fd;
        s_sockaddr_t server = {AF_PIPE, S_SERVER_SOC_PIPE};

	fd = s_socket_api_socket(AF_PIPE, SOCK_STREAM, 0);
        if (fd < 0) {
		goto err0;
	}
	if (s_socket_api_connect(fd, (s_sockaddr_t *) &server, sizeof(server)) == -1) {
		goto err1;
	}
	debugf(DCLI, "Connected to server via PIPE (%s)", S_SERVER_SOC_PIPE);
	return fd;
err1:	s_socket_api_close(fd);
err0:	return -1;
#else
	return -1;
#endif
}

int s_socket_init_wakeup (s_window_t *window)
{
	int fd[2];
	s_pollfd_t *pfd;

	if (s_pollfd_init(&pfd)) {
		goto err0;
	}
	if (s_pipe_api_pipe(fd)) {
		goto err1;
	}

	window->wsoc = fd[1];
	pfd->fd = fd[0];
	pfd->pf_in = s_socket_inw_f;
	pfd->pf_err = s_socket_ierrw_f;
	pfd->pf_close = s_socket_api_closew_f;
	if (!s_pollfd_add(window, pfd)) {
		goto err2;
	}
	
	return 0;
err2:	s_pipe_api_close(fd[0]);
	s_pipe_api_close(fd[1]);
err1:	s_pollfd_uninit(pfd);
err0:	return -1;
}

int s_socket_init (s_window_t *window)
{
	int fd;
	s_pollfd_t *pfd;

	if (((fd = s_socket_init_uds(window)) < 0) &&
	    ((fd = s_socket_init_tcp(window)) < 0) &&
	    ((fd = s_socket_init_pipe(window)) < 0)) {
		goto err0;
	}
	if (s_socket_init_wakeup(window)) {
		goto err0;
	}
	if (s_pollfd_init(&pfd)) {
		goto err0;
	}

	window->soc = fd;
        pfd->fd = fd;
        pfd->pf_in = s_socket_in_f;
        pfd->pf_err = s_socket_ierr_f;
        pfd->pf_close = s_socket_uninit;

	if (!s_pollfd_add(window, pfd)) {
		goto err1;
	}

	if (s_thread_mutex_init(&(window->socket_mutex))) {
		goto err0;
	}

	return 0;

err1:	s_pollfd_uninit(pfd);
err0:	return -1;
}