/*
 * write lines of text
 *
 * return -1 on error or bytecount
 */
static int writeline(char *buf, int len, netbuf *nData)
{
    int x, nb=0, w;
    char *ubp = buf, *nbp;
    char lc=0;

    if (nData->dir != FTPLIB_WRITE)
	return -1;
    nbp = nData->buf;
    for (x=0; x < len; x++)
    {
	if ((*ubp == '\n') && (lc != '\r'))
	{
	    if (nb == FTPLIB_BUFSIZ)
	    {
		if (!socket_wait(nData))
		    return x;
		w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
		if (w != FTPLIB_BUFSIZ)
		{
		    printf("net_write(1) returned %d, errno = %d\n", w, errno);
		    return(-1);
		}
		nb = 0;
	    }
	    nbp[nb++] = '\r';
	}
	if (nb == FTPLIB_BUFSIZ)
	{
	    if (!socket_wait(nData))
		return x;
	    w = net_write(nData->handle, nbp, FTPLIB_BUFSIZ);
	    if (w != FTPLIB_BUFSIZ)
	    {
		printf("net_write(2) returned %d, errno = %d\n", w, errno);
		return(-1);
	    }
	    nb = 0;
	}
	nbp[nb++] = lc = *ubp++;
    }
    if (nb)
    {
	if (!socket_wait(nData))
	    return x;
	w = net_write(nData->handle, nbp, nb);
	if (w != nb)
	{
	    printf("net_write(3) returned %d, errno = %d\n", w, errno);
	    return(-1);
	}
    }
    return len;
}

/*
 * HttpSendCmd - send a command
 *
 * return 1 if proper response received, 0 otherwise
 */
static int HttpSendCmd(const char *cmd, char expresp, netbuf *nControl)
{
	int ret = 0;
	char *buf = nControl->response;
	/* if (nControl->dir != FTPLIB_CONTROL)
		return 0; */
	if (ftplib_debug > 2)
		fprintf(stderr,"%s\n",cmd);
	if (net_write(nControl->handle,cmd,strlen(cmd)) <= 0)
	{
		perror("write");
		return 0;
	}
	while (ret < 256) {
		if (socket_wait(nControl) != 1)
			return 0;
		if (net_read(nControl->handle,buf,1) != 1) {
			break;
		}
		ret++;
		if (*buf == '\r') continue;
		if (*buf == '\n') break;
		buf++;
	}
	*buf = 0;
	if (nControl->response[9] == expresp)
		return 1;
	return 0;
}

/*
 * FtpWrite - write to a data connection
 */
GLOBALDEF int FtpWrite(void *buf, int len, netbuf *nData)
{
	int i;
	if (nData->dir != FTPLIB_WRITE)
		return 0;
	if (nData->buf)
		i = writeline(buf, len, nData);
	else
	{
		socket_wait(nData);
		i = net_write(nData->handle, buf, len);
	}
	if (i == -1)
		return 0;
	nData->xfered += i;
	if (nData->idlecb && nData->cbbytes)
	{
		nData->xfered1 += i;
		if (nData->xfered1 > nData->cbbytes)
		{
			nData->idlecb(nData, nData->xfered, nData->idlearg);
			nData->xfered1 = 0;
		}
	}
	return i;
}

T_ERRCODE socket_recv(
  p_socket sock, char *data, size_t len, int timeout, int *received) {
  int err, got = 0;
  if (*sock < 0) {
    return CLOSED;
  }

  int flags = fcntl(*sock, F_GETFL, 0);
  do {
    got = recv(*sock, data, len, 0);
    if (got > 0) {
      *received = got;
      return SUCCESS;
    }
    err = errno;

    // Connection has been closed by peer
    if (got == 0) {
      return CLOSED;
    }
  } while (err != EINTR);

  if (err == EAGAIN) {
    return socket_wait(sock, WAIT_MODE_R, timeout);
  }
  return err;
}

/*
 * read a line of text
 *
 * return -1 on error or bytecount
 */
static int readline (char *buf, int max, netbuf *ctl) {
    int x, retval = 0;
    char *end, *bp = buf;
    int eof = 0;

    if ((ctl->dir != FTPLIB_CONTROL) && (ctl->dir != FTPLIB_READ))
        return -1;
    if (max == 0)
        return 0;
    do {
        if (ctl->cavail > 0) {
            x = (max >= ctl->cavail) ? ctl->cavail : max - 1;
            end = (char *) memccpy(bp, ctl->cget, '\n', x);
            if (end != NULL)
                x = end - bp;
            retval += x;
            bp += x;
            *bp = '\0';
            max -= x;
            ctl->cget += x;
            ctl->cavail -= x;
            if (end != NULL) {
                bp -= 2;
                if (strcmp(bp, "\r\n") == 0) {
                    *bp++ = '\n';
                    *bp++ = '\0';
                    --retval;
                }
                break;
            }
        }
        if (max == 1) {
            *buf = '\0';
            break;
        }
        if (ctl->cput == ctl->cget) {
            ctl->cput = ctl->cget = ctl->buf;
            ctl->cavail = 0;
            ctl->cleft = FTPLIB_BUFSIZ;
        }
        if (eof) {
            if (retval == 0)
                retval = -1;
            break;
        }
        if (!socket_wait(ctl))
            return retval;
        if ((x = net_read(ctl->handle, ctl->cput, ctl->cleft)) == -1) {
            perror("read");
            retval = -1;
            break;
        }
        if (x == 0)
            eof = 1;
        ctl->cleft -= x;
        ctl->cavail += x;
        ctl->cput += x;
    } while (1);
    return retval;
}

static int kftp_get_response(knetFile *ftp)
{
#ifndef _WIN32
	unsigned char c;
#else
	char c;
#endif
	int n = 0;
	char *p;
	if (socket_wait(ftp->ctrl_fd, 1) <= 0) return 0;
	while (netread(ftp->ctrl_fd, &c, 1)) { // FIXME: this is *VERY BAD* for unbuffered I/O
		//fputc(c, stderr);
		if (n >= ftp->max_response) {
			ftp->max_response = ftp->max_response? ftp->max_response<<1 : 256;
			ftp->response = (char*)realloc(ftp->response, ftp->max_response);
		}
		ftp->response[n++] = c;
		if (c == '\n') {
			if (n >= 4 && isdigit(ftp->response[0]) && isdigit(ftp->response[1]) && isdigit(ftp->response[2])
				&& ftp->response[3] != '-') break;
			n = 0;
			continue;
		}
	}
	if (n < 2) return -1;
	ftp->response[n-2] = 0;
	return strtol(ftp->response, &p, 0);
}

/*
 * FtpRead - read from a data connection
 */
GLOBALDEF int FtpRead(void *buf, int max, netbuf *nData)
{
	int i;
	if (nData->dir != FTPLIB_READ)
		return 0;
	if (nData->buf)
		i = readline(buf, max, nData);
	else
	{
		i = socket_wait(nData);
		if (i != 1)
			return 0;
		i = net_read(nData->handle, buf, max);
	}
	if (i == -1)
		return 0;
	nData->xfered += i;
	if (nData->idlecb && nData->cbbytes)
	{
		nData->xfered1 += i;
		if (nData->xfered1 > nData->cbbytes)
		{
			if (nData->idlecb(nData, nData->xfered, nData->idlearg) == 0)
				return 0;
			nData->xfered1 = 0;
		}
	}
	return i;
}

static int kftp_send_cmd(knetFile *ftp, const char *cmd, int is_get)
{
	if (socket_wait(ftp->ctrl_fd, 0) <= 0) return -1; // socket is not ready for writing
    int len = strlen(cmd);
	if ( netwrite(ftp->ctrl_fd, cmd, len) != len ) return -1;
	return is_get? kftp_get_response(ftp) : 0;
}

/**
	@brief Wait on the client socket connected to Jabber, and process any resulting input.
	@param session Pointer to the transport_session.
	@param timeout How seconds to wait before timing out (see notes).
	@return 0 if successful, or -1 if a timeout or other error occurs, or if the server
		closes the connection at the other end.

	If @a timeout is -1, wait indefinitely for input activity to appear.  If @a timeout is
	zero, don't wait at all.  If @a timeout is positive, wait that number of seconds
	before timing out.  If @a timeout has a negative value other than -1, the results are not
	well defined.

	Read all available input from the socket and pass it through grab_incoming() (a
	callback function previously installed in the socket_manager).

	There is no guarantee that we will get a complete message from a single call.  As a
	result, the calling code should call this function in a loop until it gets a complete
	message, or until an error occurs.
*/
int session_wait( transport_session* session, int timeout ) {
	if( ! session || ! session->sock_mgr ) {
		return 0;
	}

	int ret =  socket_wait( session->sock_mgr, timeout, session->sock_id );

	if( ret ) {
		osrfLogDebug(OSRF_LOG_MARK, "socket_wait returned error code %d", ret);
	}
	return ret;
}

static int kftp_send_cmd(knetFile *ftp, const char *cmd, int is_get)
{
	ssize_t byteswritten; /*  tabix/knetfile.c:252:2: warning: ISO C90 forbids mixed declarations and code [-Wpedantic] */

	if (socket_wait(ftp->ctrl_fd, 0) <= 0)
		return -1; /* socket is not ready for writing */
	byteswritten = netwrite(ftp->ctrl_fd, cmd, strlen(cmd));
	if( 0 >= byteswritten )			/* @ubw fixed unused result warning */
	{
		PRINT_ERROR( "[kftp_send_cmd] no (%d) bytes written!\n", byteswritten);
		return -1;
	}
	return is_get? kftp_get_response(ftp) : 0;
}

T_ERRCODE socket_connect(p_socket sock, p_sa addr, int addr_len, int timeout) {
  int err;
  if (*sock < 0) {
    return CLOSED;
  }

  do {
    if (connect(*sock, addr, addr_len) == 0) {
      return SUCCESS;
    }
  } while ((err = errno) == EINTR);
  if (err != EINPROGRESS && err != EAGAIN) {
    return err;
  }
  return socket_wait(sock, WAIT_MODE_C, timeout);
}

/*
 * create a socket on sock_path and accept one client
 * require that connected client have UID of peer_uid
 * if authentication succeds, pass current process'
 * stdin and stdout, then wait for client to tell us to quit.
 */
void start_server ( char* sock_path, int sock_path_len, int peer_uid ) {
    int sock_serv, sock_client;
    sock_serv = socket_create( sock_path, sock_path_len );

    if( sock_serv < 0 ) {
        LOGE( "start_server: sock_serv error" );
        goto error;
    }

    sock_client = socket_accept( sock_serv );
    if( sock_client < 0 ) {
        LOGE( "start_server: sock_client error, sock=%s",sock_path );
        goto error;
    }

    struct ucred credentials;
    int ucred_length = sizeof( struct ucred );
    if( getsockopt( sock_client, SOL_SOCKET, SO_PEERCRED, &credentials, &ucred_length ) ) {
        LOGE( "start_server: couldn't obtain peer's credentials" );
        goto error;
    }

    if( peer_uid != credentials.uid ) {
        LOGE( "start_server: authentication error, expected uid %d, but found %d", peer_uid, credentials.uid );
        goto error;
    }

    if( socket_send_sdtio( sock_client ) != 0 ) {
        LOGE( "sending stdio failed" );
        goto error;
    }

    // gpg-agent and the real pinentry are now communicating
    // but our process must stay alive until they're finished
    // so we can exit with the actual return code
    int rc = socket_wait( sock_client );

    close( sock_client );
    close( sock_serv );
    socket_cleanup( sock_path );
    exit( rc );
error:
    close( sock_client );
    close( sock_serv );
    socket_cleanup( sock_path );
    exit( EXIT_FAILURE );
}

static off_t my_netread(int fd, void *buf, off_t len)
{
	off_t rest = len, curr, l = 0;
	/* recv() and read() may not read the required length of data with
	 * one call. They have to be called repeatedly. */
	while (rest) {
		if (socket_wait(fd, 1) <= 0) break; // socket is not ready for reading
		curr = netread(fd, (void*)((char*)buf + l), rest);
		/* According to the glibc manual, section 13.2, a zero returned
		 * value indicates end-of-file (EOF), which should mean that
		 * read() will not return zero if EOF has not been met but data
		 * are not immediately available. */
		if (curr == 0) break;
		l += curr; rest -= curr;
	}
	return l;
}

T_ERRCODE socket_accept(p_socket sock, p_socket client,
                  p_sa addr, socklen_t *addrlen, int timeout) {
  int err;
  if (*sock < 0) {
    return CLOSED;
  }
  do {
    *client = accept(*sock, addr, addrlen);
    if (*client > 0) {
      return SUCCESS;
    }
    err = errno;
  } while (err != EINTR);
  if (err == EAGAIN || err == ECONNABORTED) {
    return socket_wait(sock, WAIT_MODE_R, timeout);
  }
  return err;
}

/*
 * HttpGet - issue a GET command and write received data to output
 *
 * return 1 if successful, 0 otherwise
 */
GLOBALREF int HttpGet(const char *host, const char *outputfile, const char *path,
		int *size, netbuf *nControl, unsigned int offset)
{
	char buf[256];

	if(offset > 0)
		sprintf(buf, "GET %s HTTP/1.1\r\nHost: %s\r\nRange: bytes=%d-\r\n\r\n", path, host, offset);
	else
		sprintf(buf, "GET %s HTTP/1.1\r\nHost: %s\r\n\r\n", path, host);
	if(!HttpSendCmd(buf,'2',nControl))
	{
		if (nControl->response[9] == '3')
			printf("redirection not supported\n");
		return 0;
	}

	while (1)
	{
		int ret = 0;
		char *buf = nControl->response;
		while (ret < 256) {
			if (socket_wait(nControl) != 1)
				return 0;
			if (net_read(nControl->handle,buf,1) != 1)
				break;
			ret++;
			if (*buf == '\r') continue;
			if (*buf == '\n') break;
			buf++;
		}
		*buf = 0;
		if (strstr(nControl->response,"Content-Length"))
		{
			sscanf(nControl->response,"Content-Length: %d",size);
			if(offset > 0)
				*size += offset;
		}
		if (strlen(nControl->response) == 0)
			break;
	}

	return HttpXfer(outputfile, path, size, nControl, FTPLIB_FILE_READ, FTPLIB_IMAGE);
}

T_ERRCODE socket_send(
  p_socket sock, const char *data, size_t len, int timeout) {
  int err, put = 0;
  if (*sock < 0) {
    return CLOSED;
  }
  do {
    put = send(*sock, data, len, 0);
    if (put > 0) {
      return SUCCESS;
    }
    err = errno;
  } while (err != EINTR);

  if (err == EAGAIN) {
    return socket_wait(sock, WAIT_MODE_W, timeout);
  }
  return err;
}

/*
 * Main entry point
 */
int main(int argc, char **argv) {
	int opt_v = 0;
	char *opt_c = NULL;
	char *opt_s = NULL;
	int ch;

	/* check we're running as root */
	if(getuid() != 0) {
		errno = EACCES;
		ERR("I must be run as root\n");
		return -1;
	}

	/* handle command line arguments */
	while ((ch = getopt(argc, argv, "hvc:s:")) != -1) {
		switch (ch) {
		case 'v': // enables verbose logging
			opt_v++;
			break;

		case 'c': // allows use to override location of config
			opt_c = strdup(optarg);
			break;

		case 's': // changes location of unix socket
			opt_s = strdup(optarg);
			break;

		case 'h': // help!
		default:
			usage(argc, argv);
		}
	}

	argc -= optind;
	argv += optind;

	/* set the logging level */
	if (opt_v == 0) {
		opt_v = LOG_LEVEL_DEFAULT;
	}

	log_level(opt_v);

	INF("thermal manager starting...\n");

	/* bring up "subsystems" */
	sensor_init();
	hwmon_init();
	actions_init();

	/* read and parse sensor config file */
	if (opt_c == NULL) {
		opt_c = strdup(DEFAULT_CONFIG_FILE_PATH);
		if (opt_c == NULL) {
			ERR("unable to allocate memory\n");
			return -1;
		}
	}

	INF("parsing thermal.conf...\n");
	if (parse_config(opt_c) < 0) {
		ERR("failed to parse config file\n");
		return -1;
	}

	/* discover HWMON sensors */
	INF("discovering platform HWMON sensors...\n");
	if (hwmon_find_sensors()) {
		ERR("failed to find platform HWMON sensors\n");
		return -1;
	}

	/* startup client socket */
	if (opt_s != NULL) {
		INF("overriding default socket path (%s)!\n", opt_s);
		socket_setunixsocket(opt_s);
	}

	INF("starting client communication socket...\n");
	if (socket_init()) {
		ERR("unable to start socket communication\n");
		return -1;
	}

	/* set sensor values & start monitoring */
	INF("configuring initial sensor value...\n");
	if (sensor_configure_all()) {
		ERR("Unable to configure HWMON sensors\n");
		return -1;
	}

	/* finally stop and wait for the server thread to
	 * shutdown (ie a catostrophic error has occured)
	 */
	socket_wait();

//.........这里部分代码省略.........

int server_getline ( char *buf, int buf_size )
{
    int msglen = -1;
    char *p;

    if (g_sock == NULL) return -1;

    strcpy(buf, "");

    while (1) {
	if (g_buf_ptr == NULL) {
	    if (socket_wait(g_sock) <= 0) {
		ErrMsg("server_getline: wait error\n");
		return -1;
	    }

	    if (socket_accept(g_sock) <= 0) {
		ErrMsg("server_getline: accept failed\n");
		return -1;
	    }

	    if (g_buf_offset >= sizeof(g_buf) - 1) {
		g_buf_offset = 0;
	    } 

	    if ((msglen = socket_read(g_sock, g_buf + g_buf_offset, sizeof(g_buf) - g_buf_offset)) == -1) {
		continue;
	    } else if (msglen <= 0) {
		continue;
	    } else {
		g_buf[g_buf_offset + msglen] = '\0';
		g_buf_ptr = g_buf;
		g_buf_offset = 0;
	    }
	}

	if (g_buf_ptr != NULL) {
	    if ((p = strstr(g_buf_ptr, "./")) != NULL
		&& (p[2] == '\r' || p[2] == '\n')) {
		/* "./\n" was found */
		p[0] = '\n';
		p[1] = '\0';
		msglen = strlen(g_buf_ptr);
		strncpy(buf, g_buf_ptr, buf_size);

		if (p[2] == '\r' && p[3] == '\n') {
		    /* Windows newline "\r\n" was found */
		    p++;
		}
		
		if (p[3] == '\0') {
		    /* single line was included */
		    g_buf_ptr = NULL;
		} else {
		    /* multiple lines were included */
		    g_buf_ptr = p + 3;
		}
		g_buf_offset = 0;
		g_buf[0] = '\0';
		break;
	    } else {
		/* "./\n" was not found */
		msglen = 0;
		g_buf_offset = strlen(g_buf);
		if (g_buf_offset > 0 && g_buf[g_buf_offset - 1] == '\n') {
		    /* remove newline char */
		    if (g_buf_offset > 1 && g_buf[g_buf_offset - 2] == '\r') {
			g_buf_offset--;
		    }
		    g_buf[g_buf_offset - 1] = ' ';
		}
		g_buf_ptr = NULL;
	    }
	}
    }

    return msglen;
}

//.........这里部分代码省略.........
	element with the tag <handshake> (if we're a Jabber component) or <iq> (if we're not),
	enclosing the username, password, and resource.

	If all goes well, the Jabber server responds with a <handshake> or <iq> stanza of its own,
	and we're logged in.

	If authentication fails, the Jabber server returns a <stream:error> (if we used a <handshake>
	or an <iq> of type "error" (if we used an <iq>).
	*/
	if( session->component ) {

		/* the first Jabber connect stanza */
		char our_hostname[HOST_NAME_MAX + 1] = "";
		gethostname(our_hostname, sizeof(our_hostname) );
		our_hostname[HOST_NAME_MAX] = '\0';
		size1 = 150 + strlen( username ) + strlen( our_hostname );
		char stanza1[ size1 ];
		snprintf( stanza1, sizeof(stanza1),
				"<stream:stream version='1.0' xmlns:stream='http://etherx.jabber.org/streams' "
				"xmlns='jabber:component:accept' to='%s' from='%s' xml:lang='en'>",
				username, our_hostname );

		/* send the first stanze */
		session->state_machine->connecting = CONNECTING_1;

		if( socket_send( session->sock_id, stanza1 ) ) {
			osrfLogWarning(OSRF_LOG_MARK, "error sending");
			socket_disconnect( session->sock_mgr, session->sock_id );
			session->sock_id = 0;
			return 0;
		}

		/* wait for reply */
		socket_wait(session->sock_mgr, connect_timeout, session->sock_id);

		/* server acknowledges our existence, now see if we can login */
		if( session->state_machine->connecting == CONNECTING_2 ) {

			int ss = buffer_length( session->session_id ) + strlen( password ) + 5;
			char hashstuff[ss];
			snprintf( hashstuff, sizeof(hashstuff), "%s%s",
					OSRF_BUFFER_C_STR( session->session_id ), password );

			char* hash = shahash( hashstuff );
			size2 = 100 + strlen( hash );
			char stanza2[ size2 ];
			snprintf( stanza2, sizeof(stanza2), "<handshake>%s</handshake>", hash );

			if( socket_send( session->sock_id, stanza2 )  ) {
				osrfLogWarning(OSRF_LOG_MARK, "error sending");
				socket_disconnect( session->sock_mgr, session->sock_id );
				session->sock_id = 0;
				return 0;
			}
		}

	} else { /* we're not a component */

		/* the first Jabber connect stanza */
		size1 = 100 + strlen( server );
		char stanza1[ size1 ];
		snprintf( stanza1, sizeof(stanza1),
				"<stream:stream to='%s' xmlns='jabber:client' "
				"xmlns:stream='http://etherx.jabber.org/streams'>",
			server );

//.........这里部分代码省略.........
			break;
		switch(c) {
			case 'H':
				printf("Usage: %s [options]\n", progname);
				printf("\t -H --help\t\tdisplay usage summary\n");
				printf("\t -V --version\t\tdisplay version\n");
				printf("\t -S --settings\t\tsettings file\n");
				printf("\t -D --nodaemon\t\tdo not daemonize and\n");
				printf("\t\t\t\tshow debug information\n");
				return (EXIT_SUCCESS);
			break;
			case 'V':
				printf("%s %s\n", progname, "1.0");
				return (EXIT_SUCCESS);
			break;
			case 'D':
				nodaemon=1;
			break;
			default:
				printf("Usage: %s [options]\n", progname);
				return (EXIT_FAILURE);
			break;
		}
	}
	options_delete(options);

	pid_file = malloc(sizeof(PID_FILE)+1);
	strcpy(pid_file, PID_FILE);

	template_file = malloc(14);
	strcpy(template_file, "template.json");

	if((f = open(pid_file, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR)) != -1) {
		if(read(f, buffer, BUFFER_SIZE) != -1) {
			//If the file is empty, create a new process
			if(!atoi(buffer)) {
				running = 0;
			} else {
				//Check if the process is running
				kill(atoi(buffer), 0);
				//If not, create a new process
				if(errno == ESRCH) {
					running = 0;
				}
			}
		}
	} else {
		logprintf(LOG_ERR, "could not open / create pid_file %s", pid_file);
		return EXIT_FAILURE;
	}
	close(f);

	if(nodaemon == 1 || running == 1) {
		log_level_set(LOG_DEBUG);
	}

	if(running == 1) {
		nodaemon=1;
		logprintf(LOG_NOTICE, "already active (pid %d)", atoi(buffer));
		return EXIT_FAILURE;
	}

	if(nodaemon == 0) {
		deamonize();
		socket_start(PORT);
		fb_init();
	} else {
		socket_start(PORT);
	}

	if(template_read(template_file) == EXIT_FAILURE) {
		logprintf(LOG_NOTICE, "failed to read template file %s", template_file);
		main_gc();
		return EXIT_FAILURE;
	}

	if(nodaemon == 1) {
		//template_print();
	}

    //initialise all socket_clients and handshakes to 0 so not checked
	memset(socket_clients, 0, sizeof(socket_clients));

    socket_callback.client_disconnected_callback = NULL;
    socket_callback.client_connected_callback = NULL;
    socket_callback.client_data_callback = &socket_parse_data;

	main_draw();

	/* Make sure the server part is non-blocking by creating a new thread */
	pthread_create(&pth, NULL, &update_progress, (void *)NULL);

	socket_wait((void *)&socket_callback);

	while(main_loop) {
		sleep(1);
	}

	return EXIT_FAILURE;
}