void main() { static long address; static int retval; sock_init(); // Wait for the interface to come up while (ifpending(IF_DEFAULT) == IF_COMING_UP) { tcp_tick(NULL); } pop3_init(storemsg); printf("Resolving name...\n"); address = resolve(POP_HOST); printf("Calling pop3_getmail()...\n"); pop3_getmail(POP_USER, POP_PASS, address); printf("Entering pop3_tick()...\n"); while((retval = pop3_tick()) == POP_PENDING) continue; if(retval == POP_SUCCESS) printf("POP was successful!\n"); if(retval == POP_TIME) printf("POP timed out!\n"); if(retval == POP_ERROR) printf("POP returned a general error!\n"); printf("All done!\n"); }
/*********************************************************************** * * pop3_do() * * This function is registered as 'curl_do' function. It decodes the path * parts etc as a wrapper to the actual DO function (pop3_perform). * * The input argument is already checked for validity. */ static CURLcode pop3_do(struct connectdata *conn, bool *done) { CURLcode retcode = CURLE_OK; *done = FALSE; /* default to false */ /* Since connections can be re-used between SessionHandles, this might be a connection already existing but on a fresh SessionHandle struct so we must make sure we have a good 'struct POP3' to play with. For new connections, the struct POP3 is allocated and setup in the pop3_connect() function. */ Curl_reset_reqproto(conn); retcode = pop3_init(conn); if(retcode) return retcode; retcode = pop3_parse_url_path(conn); if(retcode) return retcode; retcode = pop3_regular_transfer(conn, done); return retcode; }
/*********************************************************************** * * pop3_do() * * This function is registered as 'curl_do' function. It decodes the path * parts etc as a wrapper to the actual DO function (pop3_perform). * * The input argument is already checked for validity. */ static CURLcode pop3_do(struct connectdata *conn, bool *done) { CURLcode result = CURLE_OK; *done = FALSE; /* default to false */ /* Since connections can be re-used between SessionHandles, there might be a connection already existing but on a fresh SessionHandle struct. As such we make sure we have a good POP3 struct to play with. For new connections the POP3 struct is allocated and setup in the pop3_connect() function. */ Curl_reset_reqproto(conn); result = pop3_init(conn); if(result) return result; /* Parse the URL path */ result = pop3_parse_url_path(conn); if(result) return result; /* Parse the custom request */ result = pop3_parse_custom_request(conn); if(result) return result; result = pop3_regular_transfer(conn, done); return result; }
static CURLcode pop3_setup_connection(struct connectdata *conn) { /* Initialise the POP3 layer */ CURLcode result = pop3_init(conn); if(result) return result; /* Clear the TLS upgraded flag */ conn->tls_upgraded = FALSE; return CURLE_OK; }
/* * pop3_connect() should do everything that is to be considered a part of * the connection phase. * * The variable 'done' points to will be TRUE if the protocol-layer connect * phase is done when this function returns, or FALSE is not. When called as * a part of the easy interface, it will always be TRUE. */ static CURLcode pop3_connect(struct connectdata *conn, bool *done) /* see description above */ { CURLcode result; struct pop3_conn *pop3c = &conn->proto.pop3c; struct SessionHandle *data=conn->data; struct pingpong *pp = &pop3c->pp; *done = FALSE; /* default to not done yet */ /* If there already is a protocol-specific struct allocated for this sessionhandle, deal with it */ Curl_reset_reqproto(conn); result = pop3_init(conn); if(CURLE_OK != result) return result; /* We always support persistent connections on pop3 */ conn->bits.close = FALSE; pp->response_time = RESP_TIMEOUT; /* set default response time-out */ pp->statemach_act = pop3_statemach_act; pp->endofresp = pop3_endofresp; pp->conn = conn; if(conn->handler->flags & PROTOPT_SSL) { /* BLOCKING */ result = Curl_ssl_connect(conn, FIRSTSOCKET); if(result) return result; } Curl_pp_init(pp); /* init the response reader stuff */ /* When we connect, we start in the state where we await the server greet response */ state(conn, POP3_SERVERGREET); if(data->state.used_interface == Curl_if_multi) result = pop3_multi_statemach(conn, done); else { result = pop3_easy_statemach(conn); if(!result) *done = TRUE; } return result; }
/*********************************************************************** * * pop3_connect() * * This function should do everything that is to be considered a part of the * connection phase. * * The variable 'done' points to will be TRUE if the protocol-layer connect * phase is done when this function returns, or FALSE is not. When called as * a part of the easy interface, it will always be TRUE. */ static CURLcode pop3_connect(struct connectdata *conn, bool *done) { CURLcode result; struct pop3_conn *pop3c = &conn->proto.pop3c; struct pingpong *pp = &pop3c->pp; *done = FALSE; /* default to not done yet */ /* If there already is a protocol-specific struct allocated for this sessionhandle, deal with it */ Curl_reset_reqproto(conn); result = pop3_init(conn); if(CURLE_OK != result) return result; /* We always support persistent connections on pop3 */ conn->bits.close = FALSE; pp->response_time = RESP_TIMEOUT; /* set default response time-out */ pp->statemach_act = pop3_statemach_act; pp->endofresp = pop3_endofresp; pp->conn = conn; if(conn->handler->flags & PROTOPT_SSL) { /* POP3S is simply pop3 with SSL for the control channel */ /* so perform the SSL initialization for this socket */ result = Curl_ssl_connect(conn, FIRSTSOCKET); if(result) return result; } /* Initialise the response reader stuff */ Curl_pp_init(pp); /* Start off waiting for the server greeting response */ state(conn, POP3_SERVERGREET); result = pop3_multi_statemach(conn, done); return result; }
static CURLcode pop3_setup_connection(struct connectdata *conn) { struct SessionHandle *data = conn->data; /* Initialise the POP3 layer */ CURLcode result = pop3_init(conn); if(result) return result; /* Clear the TLS upgraded flag */ conn->tls_upgraded = FALSE; /* Set up the proxy if necessary */ if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) { /* Unless we have asked to tunnel POP3 operations through the proxy, we switch and use HTTP operations only */ #ifndef CURL_DISABLE_HTTP if(conn->handler == &Curl_handler_pop3) conn->handler = &Curl_handler_pop3_proxy; else { #ifdef USE_SSL conn->handler = &Curl_handler_pop3s_proxy; #else failf(data, "POP3S not supported!"); return CURLE_UNSUPPORTED_PROTOCOL; #endif } /* set it up as an HTTP connection instead */ return conn->handler->setup_connection(conn); #else failf(data, "POP3 over http proxy requires HTTP support built-in!"); return CURLE_UNSUPPORTED_PROTOCOL; #endif } data->state.path++; /* don't include the initial slash */ return CURLE_OK; }
/*********************************************************************** * * pop3_connect() * * This function should do everything that is to be considered a part of the * connection phase. * * The variable 'done' points to will be TRUE if the protocol-layer connect * phase is done when this function returns, or FALSE is not. When called as * a part of the easy interface, it will always be TRUE. */ static CURLcode pop3_connect(struct connectdata *conn, bool *done) { CURLcode result = CURLE_OK; struct pop3_conn *pop3c = &conn->proto.pop3c; struct pingpong *pp = &pop3c->pp; *done = FALSE; /* default to not done yet */ /* If there already is a protocol-specific struct allocated for this sessionhandle, deal with it */ Curl_reset_reqproto(conn); /* Initialise the POP3 layer */ result = pop3_init(conn); if(result) return result; /* We always support persistent connections in POP3 */ conn->bits.close = FALSE; /* Set the default response time-out */ pp->response_time = RESP_TIMEOUT; pp->statemach_act = pop3_statemach_act; pp->endofresp = pop3_endofresp; pp->conn = conn; /* Initialise the pingpong layer */ Curl_pp_init(pp); /* Start off waiting for the server greeting response */ state(conn, POP3_SERVERGREET); result = pop3_multi_statemach(conn, done); return result; }
/* * pop3_connect() should do everything that is to be considered a part of * the connection phase. * * The variable 'done' points to will be TRUE if the protocol-layer connect * phase is done when this function returns, or FALSE is not. When called as * a part of the easy interface, it will always be TRUE. */ static CURLcode pop3_connect(struct connectdata *conn, bool *done) /* see description above */ { CURLcode result; struct pop3_conn *pop3c = &conn->proto.pop3c; struct SessionHandle *data=conn->data; struct pingpong *pp = &pop3c->pp; *done = FALSE; /* default to not done yet */ /* If there already is a protocol-specific struct allocated for this sessionhandle, deal with it */ Curl_reset_reqproto(conn); result = pop3_init(conn); if(CURLE_OK != result) return result; /* We always support persistent connections on pop3 */ conn->bits.close = FALSE; pp->response_time = RESP_TIMEOUT; /* set default response time-out */ pp->statemach_act = pop3_statemach_act; pp->endofresp = pop3_endofresp; pp->conn = conn; if(conn->bits.tunnel_proxy && conn->bits.httpproxy) { /* for POP3 over HTTP proxy */ struct HTTP http_proxy; struct FTP *pop3_save; /* BLOCKING */ /* We want "seamless" POP3 operations through HTTP proxy tunnel */ /* Curl_proxyCONNECT is based on a pointer to a struct HTTP at the member * conn->proto.http; we want POP3 through HTTP and we have to change the * member temporarily for connecting to the HTTP proxy. After * Curl_proxyCONNECT we have to set back the member to the original struct * POP3 pointer */ pop3_save = data->state.proto.pop3; memset(&http_proxy, 0, sizeof(http_proxy)); data->state.proto.http = &http_proxy; result = Curl_proxyCONNECT(conn, FIRSTSOCKET, conn->host.name, conn->remote_port); data->state.proto.pop3 = pop3_save; if(CURLE_OK != result) return result; } if(conn->handler->flags & PROTOPT_SSL) { /* BLOCKING */ result = Curl_ssl_connect(conn, FIRSTSOCKET); if(result) return result; } Curl_pp_init(pp); /* init the response reader stuff */ /* When we connect, we start in the state where we await the server greet response */ state(conn, POP3_SERVERGREET); if(data->state.used_interface == Curl_if_multi) result = pop3_multi_statemach(conn, done); else { result = pop3_easy_statemach(conn); if(!result) *done = TRUE; } return result; }