/**
 * Sends a response to a client.
 * @arg connptr The client connection
 * @arg msg_buffer A list of response buffers to send
 * @arg buf_size A list of the buffer sizes
 * @arg type message type either TCP or UDP
 * @return 0 on success.
 */
int send_proxy_msg(void *connptr, char *msg_buffer, int buf_size) {

    // Retrieve connection
    proxy_conn_info * proxy_conn = (proxy_conn_info *) connptr;
    conn_info * conn;

    // Check that we are connected
    if (! proxy_conn->connected) {
    	int res = connect_proxy(proxy_conn);
    	if (res) {
    		syslog(LOG_DEBUG, "Failed to send: %s", msg_buffer);
    		return 1;
    	}
    }

    conn = proxy_conn->tcp;

    // Bail if we shouldn't schedule
    if (!conn->should_schedule) return 0;

    // Check if we are doing buffered writes
    if (conn->use_write_buf) {
        return send_proxy_msg_buffered(conn, msg_buffer, buf_size);
    } else {
        return send_proxy_msg_direct(conn, msg_buffer, buf_size);
    }
}
/**
 * Invoked when a TCP listening socket fd is ready
 * to accept a new client. Accepts the client, initializes
 * the connection buffers, and prepares to start listening
 * for client data
 */
static int setup_proxy_connections(statsite_proxy_networking *netconf) {

	proxy* proxy = netconf->proxy;
	ketama_serverinfo* serverinfo = hashring_getserver_info(proxy->hashring);

	char *addr;
	char *token;

	int tcp_fd;

	proxy_conn_info* proxy_conn;

	for (int i = 0; i < serverinfo->numservers; i++) {
		addr = NULL;
		addr = serverinfo->serverinfo[i].addr;

		// Create proxy_conn struct
		proxy_conn = get_proxy_conn(netconf);
		proxy_conn->addr = addr;

		// Attempt to connect
		connect_proxy(proxy_conn);

		// Store proxy connection for later use
		proxy_put_conn(proxy, addr, (void*) proxy_conn);

	}

	return 0;
}
Example #3
0
int login_callback(struct authinfo *ainfo, void *dummy)
{
	int rc;
	const char *tag=(const char *)dummy;
	char *p;

	p=getenv("IMAP_PROXY");

	if (p && atoi(p))
	{
		if (ainfo->options == NULL ||
		    (p=auth_getoption(ainfo->options,
				      "mailhost")) == NULL)
		{
			fprintf(stderr, "WARN: proxy enabled, but no proxy"
				 " host defined for %s\n",
				 ainfo->address);

			/* Fallthru to account login */

		}
		else if (ainfo->clearpasswd == NULL)
		{
			free(p);
			fprintf(stderr, "WARN: proxy enabled, but no password"
				 " for %s\n", ainfo->address);
			return -1;
		}
		else
		{
			struct proxyinfo pi;
			struct imapproxyinfo ipi;
			struct servent *se;
			int fd;

			se=getservbyname("imap", NULL);

			pi.host=p;
			pi.port=se ? ntohs(se->s_port):143;

			ipi.uid=ainfo->address;
			ipi.pwd=ainfo->clearpasswd;
			ipi.tag=tag;

			pi.connected_func=login_imap;
			pi.void_arg=&ipi;

			if ((fd=connect_proxy(&pi)) < 0)
			{
				free(p);
				return -1;
			}
			free(p);
			if (fd > 0)
			{
				alarm(0);
				proxyloop(fd);
				exit(0);
			}

			/* FALLTHRU */
		}
	}

	rc=auth_callback_default(ainfo);

	if (rc == 0)
	{
		p=malloc(sizeof("OPTIONS=") + strlen(ainfo->options ?
						     ainfo->options:""));

		if (p)
		{
			strcat(strcpy(p, "OPTIONS="),
			       ainfo->options ? ainfo->options:"");
			putenv(p);

			p=malloc(sizeof("IMAPLOGINTAG=")+strlen(tag));
			if (p)
			{
				strcat(strcpy(p, "IMAPLOGINTAG="), tag);
				putenv(p);

				p=malloc(sizeof("AUTHENTICATED=")+
					 strlen(ainfo->address));
				if (p)
				{
					strcat(strcpy(p, "AUTHENTICATED="),
					       ainfo->address);
					putenv(p);
					alarm(0);
					execl(imapd, imapd,
					      ainfo->maildir ?
					      ainfo->maildir:defaultmaildir,
					      NULL);
					fprintf(stderr, "ERR: exec(%s) failed!!\n",
								 imapd);
				}
			}
		}
	}

	return(rc);
}