int newsnntp_post(newsnntp * f, const char * message, size_t size)
{
char command[NNTP_STRING_SIZE];
int r;
char * response;
snprintf(command, NNTP_STRING_SIZE, "POST\r\n");
r = send_command(f, command);
if (r == -1)
return NEWSNNTP_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 340:
break;
case 440:
return NEWSNNTP_ERROR_POSTING_NOT_ALLOWED;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
send_data(f, message, size);
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 240:
return NEWSNNTP_NO_ERROR;
return 1;
case 441:
return NEWSNNTP_ERROR_POSTING_FAILED;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
void signup_signin() {
int i, authen = 0;
char action[10], input[50], request[256];
char **response;
printf("signup/signin? ");
scanf(" %s", action);
while(!authen) {
sprintf(request, "%s,", action);
if (strcmp(action, "signup") == 0) {
printf("[username] [nickname] [password]: ");
for (i = 0; i < L_SIGNUP_REQ; i++) {
scanf(" %s", input);
strcat(request, input);
strcat(request, ",");
}
getchar();
if(send(sock, request, strlen(request) , 0) < 0)
ERR_EXIT("Send failed");
response = parse_response(L_SIGN_RES);
if (strcmp(response[0], "success") == 0) {
strcpy(user->username, response[1]);
strcpy(user->nickname, response[2]);
authen = 1;
}
else
printf("%s\n", response[0]);
} else if (strcmp(action, "signin") == 0) {
printf("[username] [password]: ");
for (i = 0; i < L_SIGNIN_REQ; i++) {
scanf(" %s", input);
strcat(request, input);
strcat(request, ",");
}
getchar();
if(send(sock, request, strlen(request) , 0) < 0)
ERR_EXIT("Send failed");
response = parse_response(L_SIGN_RES);
if (strcmp(response[0], "success") == 0) {
strcpy(user->username, response[1]);
strcpy(user->nickname, response[2]);
authen = 1;
}
else
printf("%s\n", response[0]);
}
}
free(response);
}
int phr_parse_response(const char* buf_start, size_t len, int* minor_version,
int* status, const char** msg, size_t* msg_len,
struct phr_header* headers, size_t* num_headers,
size_t last_len)
{
const char * buf = buf_start, * buf_end = buf + len;
size_t max_headers = *num_headers;
int r;
*minor_version = -1;
*status = 0;
*msg = NULL;
*msg_len = 0;
*num_headers = 0;
/* if last_len != 0, check if the response is complete (a fast countermeasure
against slowloris */
if (last_len != 0 && is_complete(buf, buf_end, last_len, &r) == NULL) {
return r;
}
if ((buf = parse_response(buf, buf_end, minor_version, status, msg, msg_len,
headers, num_headers, max_headers, &r))
== NULL) {
return r;
}
return buf - buf_start;
}
int newsnntp_connect(newsnntp * f, mailstream * s)
{
char * response;
int r;
if (f->nntp_stream != NULL)
return NEWSNNTP_ERROR_BAD_STATE;
f->nntp_stream = s;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 200:
f->nntp_readonly = FALSE;
return NEWSNNTP_NO_ERROR;
case 201:
f->nntp_readonly = TRUE;
return NEWSNNTP_NO_ERROR;
default:
f->nntp_stream = NULL;
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
//LCOV_EXCL_START - don't want to actually run the handlers in the UT
void RegistrationTimeoutTask::run()
{
if (_req.method() != htp_method_POST)
{
send_http_reply(HTTP_BADMETHOD);
delete this;
return;
}
HTTPCode rc = parse_response(_req.get_rx_body());
if (rc != HTTP_OK)
{
LOG_DEBUG("Unable to parse response from Chronos");
send_http_reply(rc);
delete this;
return;
}
send_http_reply(HTTP_OK);
SAS::Marker start_marker(trail(), MARKER_ID_START, 1u);
SAS::report_marker(start_marker);
handle_response();
SAS::Marker end_marker(trail(), MARKER_ID_END, 1u);
SAS::report_marker(end_marker);
delete this;
}
int mailpop3_pass(mailpop3 * f, const char * password)
{
char command[POP3_STRING_SIZE];
int r;
char * response;
if (f->pop3_state != POP3_STATE_AUTHORIZATION)
return MAILPOP3_ERROR_BAD_STATE;
/* send password command */
snprintf(command, POP3_STRING_SIZE, "PASS %s\r\n", password);
r = send_command_private(f, command, 0);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_BAD_PASSWORD;
f->pop3_state = POP3_STATE_TRANSACTION;
return MAILPOP3_NO_ERROR;
}
int newsnntp_mode_reader(newsnntp * f)
{
char command[NNTP_STRING_SIZE];
char * response;
int r;
snprintf(command, NNTP_STRING_SIZE, "MODE READER\r\n");
r = send_command(f, command);
if (r == -1)
return NEWSNNTP_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 200:
case 201:
return NEWSNNTP_NO_ERROR;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
int newsnntp_quit(newsnntp * f)
{
char command[NNTP_STRING_SIZE];
char * response;
int r;
int res;
if (f->nntp_stream == NULL)
return NEWSNNTP_ERROR_BAD_STATE;
snprintf(command, NNTP_STRING_SIZE, "QUIT\r\n");
r = send_command(f, command);
if (r == -1) {
res = NEWSNNTP_ERROR_STREAM;
goto close;
}
response = read_line(f);
if (response == NULL) {
res = NEWSNNTP_ERROR_STREAM;
goto close;
}
parse_response(f, response);
res = NEWSNNTP_NO_ERROR;
close:
mailstream_close(f->nntp_stream);
f->nntp_stream = NULL;
return res;
}
//LCOV_EXCL_START - don't want to actually run the handlers in the UT
void RegistrationTimeoutHandler::run()
{
if (_req.method() != htp_method_POST)
{
send_http_reply(HTTP_BADMETHOD);
delete this;
return;
}
HTTPCode rc = parse_response(_req.body());
if (rc != HTTP_OK)
{
LOG_DEBUG("Unable to parse response from Chronos");
send_http_reply(rc);
delete this;
return;
}
send_http_reply(HTTP_OK);
SAS::Marker start_marker(trail(), MARKER_ID_START, 1u);
SAS::report_marker(start_marker);
SAS::Marker calling_dn(trail(), MARKER_ID_CALLING_DN, 1u);
calling_dn.add_var_param(_aor_id);
SAS::report_marker(calling_dn);
handle_response();
SAS::Marker end_marker(trail(), MARKER_ID_END, 1u);
SAS::report_marker(end_marker);
delete this;
}
int mailpop3_dele(mailpop3 * f, unsigned int indx)
{
char command[POP3_STRING_SIZE];
struct mailpop3_msg_info * msginfo;
char * response;
int r;
if (f->pop3_state != POP3_STATE_TRANSACTION)
return MAILPOP3_ERROR_BAD_STATE;
msginfo = find_msg(f, indx);
if (msginfo == NULL) {
f->pop3_response = NULL;
return MAILPOP3_ERROR_NO_SUCH_MESSAGE;
}
snprintf(command, POP3_STRING_SIZE, "DELE %i\r\n", indx);
r = send_command(f, command);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_NO_SUCH_MESSAGE;
msginfo->msg_deleted = TRUE;
f->pop3_deleted_count ++;
return MAILPOP3_NO_ERROR;
}
int mailpop3_rset(mailpop3 * f)
{
char command[POP3_STRING_SIZE];
char * response;
int r;
if (f->pop3_state != POP3_STATE_TRANSACTION)
return MAILPOP3_ERROR_BAD_STATE;
snprintf(command, POP3_STRING_SIZE, "RSET\r\n");
r = send_command(f, command);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
parse_response(f, response);
if (f->pop3_msg_tab != NULL) {
mailpop3_msg_info_tab_reset(f->pop3_msg_tab);
f->pop3_deleted_count = 0;
}
return MAILPOP3_NO_ERROR;
}
static void handle_response(GObex *obex, GError *err, GObexPacket *rsp)
{
struct pending_pkt *p = obex->pending_req;
gboolean disconn = err ? TRUE : FALSE, final_rsp = TRUE;
if (rsp != NULL)
final_rsp = parse_response(obex, rsp);
if (p->cancelled)
err = g_error_new(G_OBEX_ERROR, G_OBEX_ERROR_CANCELLED,
"The operation was cancelled");
if (err)
g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", err->message);
if (p->rsp_func) {
p->rsp_func(obex, err, rsp, p->rsp_data);
/* Check if user callback removed the request */
if (p != obex->pending_req)
return;
}
if (p->cancelled)
g_error_free(err);
if (final_rsp) {
pending_pkt_free(p);
obex->pending_req = NULL;
}
if (!disconn && g_queue_get_length(obex->tx_queue) > 0)
enable_tx(obex);
}
int mailpop3_capa(mailpop3 * f, clist ** result)
{
clist * capa_list;
char command[POP3_STRING_SIZE];
int r;
char * response;
snprintf(command, POP3_STRING_SIZE, "CAPA\r\n");
r = send_command(f, command);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_CAPA_NOT_SUPPORTED;
capa_list = NULL;
r = read_capa_resp(f, &capa_list);
if (r != MAILPOP3_NO_ERROR)
return r;
* result = capa_list;
return MAILPOP3_NO_ERROR;
}
static int suspend(const struct ether_addr *mac, struct message_buffer *buf)
{
struct response *response = &buf->u.response;
struct agent *agent = find_agent_by_mac(list, mac);
int n;
if (agent == NULL)
return 404;
if (agent->state == SUSPENDED)
return 409;
if (agent->fd2 < 0) // no connection to the agent
return 500;
send_request(agent->fd2, SUSP, NULL, NULL, buf);
n = read(agent->fd2, buf->chars, sizeof(buf->chars) - 1);
if (n <= 0) {
if (n < 0)
WARNING("read() failed: %m");
else
WARNING("unexpected EOF while waiting for a response");
return 500;
}
buf->chars[n] = 0;
if (parse_response(buf->chars, response)) {
WARNING("invalid response");
return 500;
}
switch (response->status) {
case 200:
return 200;
default:
WARNING("got unexpected response status code: %d", response->status);
return 500;
}
}
static int newsnntp_xover_resp(newsnntp * f, clist ** result)
{
int r;
char * response;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 224:
* result = read_xover_resp_list(f);
return NEWSNNTP_NO_ERROR;
case 412:
return NEWSNNTP_ERROR_NO_NEWSGROUP_SELECTED;
case 420:
return NEWSNNTP_ERROR_NO_ARTICLE_SELECTED;
case 502:
return NEWSNNTP_ERROR_NO_PERMISSION;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
int mailpop3_user(mailpop3 * f, const char * user)
{
char command[POP3_STRING_SIZE];
int r;
char * response;
if (f->pop3_state != POP3_STATE_AUTHORIZATION)
return MAILPOP3_ERROR_BAD_STATE;
/* send user command */
snprintf(command, POP3_STRING_SIZE, "USER %s\r\n", user);
r = send_command_private(f, command, 0);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_BAD_USER;
return MAILPOP3_NO_ERROR;
}
static int mailpop3_do_uidl(mailpop3 * f, carray * msg_tab)
{
char command[POP3_STRING_SIZE];
int r;
char * response;
if (f->pop3_state != POP3_STATE_TRANSACTION)
return MAILPOP3_ERROR_BAD_STATE;
/* send list command */
snprintf(command, POP3_STRING_SIZE, "UIDL\r\n");
r = send_command(f, command);
if (r == -1)
return MAILPOP3_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return MAILPOP3_ERROR_STREAM;
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_CANT_LIST;
r = read_uidl(f, msg_tab);
if (r != MAILPOP3_NO_ERROR)
return r;
return MAILPOP3_NO_ERROR;
}
int newsnntp_list_active(newsnntp * f, const char * wildcard, clist ** result)
{
char command[NNTP_STRING_SIZE];
int r;
char * response;
if (wildcard != NULL)
snprintf(command, NNTP_STRING_SIZE, "LIST ACTIVE %s\r\n", wildcard);
else
snprintf(command, NNTP_STRING_SIZE, "LIST ACTIVE\r\n");
r = send_command(f, command);
if (r == -1)
return NEWSNNTP_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 215:
* result = read_groups_list(f);
return NEWSNNTP_NO_ERROR;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
int mailpop3_connect(mailpop3 * f, mailstream * s)
{
char * response;
int r;
char * timestamp;
if (f->pop3_state != POP3_STATE_DISCONNECTED)
return MAILPOP3_ERROR_BAD_STATE;
f->pop3_stream = s;
response = read_line(f);
r = parse_response(f, response);
if (r != RESPONSE_OK)
return MAILPOP3_ERROR_UNAUTHORIZED;
f->pop3_state = POP3_STATE_AUTHORIZATION;
timestamp = mailpop3_get_timestamp(f->pop3_response);
if (timestamp != NULL)
f->pop3_timestamp = timestamp;
return MAILPOP3_NO_ERROR;
}
static int parse_auth(mailpop3 * f, char * response)
{
char * msg;
if (response == NULL) {
f->pop3_response = NULL;
return RESPONSE_ERR;
}
if ((strncmp(response, RESP_AUTH_CONT_STR, strlen(RESP_AUTH_CONT_STR)) == 0) &&
(strncmp(response, RESP_OK_STR, strlen(RESP_OK_STR)) != 0)) {
if (response[strlen(RESP_AUTH_CONT_STR)] == ' ')
msg = response + strlen(RESP_AUTH_CONT_STR) + 1;
else
msg = response + strlen(RESP_AUTH_CONT_STR);
if (mmap_string_assign(f->pop3_response_buffer, msg))
f->pop3_response = f->pop3_response_buffer->str;
else
f->pop3_response = NULL;
return RESPONSE_AUTH_CONT;
}
else {
return parse_response(f, response);
}
}
int newsnntp_list_distribution(newsnntp * f, clist ** result)
{
char command[NNTP_STRING_SIZE];
int r;
char * response;
snprintf(command, NNTP_STRING_SIZE, "LIST DISTRIBUTION\r\n");
r = send_command(f, command);
if (r == -1)
return NEWSNNTP_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 215:
* result = read_distrib_value_meaning_list(f);
return NEWSNNTP_NO_ERROR;
case 503:
return NEWSNNTP_ERROR_PROGRAM_ERROR;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
int newsnntp_authinfo_password(newsnntp * f, const char * password)
{
char command[NNTP_STRING_SIZE];
int r;
char * response;
snprintf(command, NNTP_STRING_SIZE, "AUTHINFO PASS %s\r\n", password);
r = send_command_private(f, command, 0);
if (r == -1)
return NEWSNNTP_ERROR_STREAM;
response = read_line(f);
if (response == NULL)
return NEWSNNTP_ERROR_STREAM;
r = parse_response(f, response);
switch (r) {
case 480:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_USERNAME;
case 482:
return NEWSNNTP_ERROR_AUTHENTICATION_REJECTED;
case 381:
return NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD;
case 281:
return NEWSNNTP_NO_ERROR;
default:
return NEWSNNTP_ERROR_UNEXPECTED_RESPONSE;
}
}
RedisReply Redis::parse_response(StreamReader& s)
{
RedisReply r;
char next_byte;
s.read_plain(next_byte);
r.type = next_byte;
switch(next_byte) {
case '+':
case '-':
case ':':
{
s.read_until("\r", r.reply, true);
s.read_plain(next_byte);
s.fail_if(next_byte != '\n');
break;
}
case '$':
{
string length_string;
s.read_until("\r", length_string, true);
s.read_plain(next_byte);
s.fail_if(next_byte != '\n');
auto length = atol(length_string.c_str());
if (length >= 0) {
if (length > 0) {
r.reply.resize(length);
s.read_size(length, &r.reply[0]);
}
char crlf[2];
s.read_size(sizeof(crlf), crlf);
s.fail_if(strncmp(crlf, "\r\n", 2) != 0);
} else {
r.type = ' ';
}
break;
}
case '*':
{
string length_string;
s.read_until("\r", length_string, true);
s.read_plain(next_byte);
s.fail_if(next_byte != '\n');
auto length = atol(length_string.c_str());
if (length > 0) {
for (long i = 0; i < length; i++) {
r.elements.push_back(parse_response(s));
}
}
break;
}
}
return r;
}
static int parse_response_ptr_lua( lua_State *L )
{
lhttp_t *h = luaL_checkudata( L, 1, MODULE_MT );
char *buf = (char*)lua_topointer( L, 4 );
size_t len = luaL_checkinteger( L, 5 );
return parse_response( L, h, buf, len );
}
static int parse_response_lua( lua_State *L )
{
lhttp_t *h = luaL_checkudata( L, 1, MODULE_MT );
size_t len = 0;
char *buf = (char*)luaL_checklstring( L, 4, &len );
return parse_response( L, h, buf, len );
}
int main( int argc, const char *argv[] )
{
printf("parse_request:\n");
parse_request();
printf("parse_response:\n");
parse_response();
return 0;
}
void read_port_list_done(struct bufferevent *bev, void* args) {
hoststate_t* state = (hoststate_t*) args;
log_trace("read-port-list-done", "%s", state->ip_address_str);
char replyCode[REPLY_CODE_SIZE];
RespResult_e res = parse_response(bev, state, replyCode);
switch (res) {
case (RESP_INCOMPLETE) :
log_debug(
"read-port-list-done",
"%s: Partial response",
state->ip_address_str
);
break;
case (RESP_FOUND) :
record_raw_dbuffer(
state,
RECKEY_BAD_PORT_LIST_DONE,
NULL,
0,
&state->ctrlDBuffer
);
if (is_reply_code(replyCode, FTP_XFER_OK)) {
log_info(
"read-port-list-done",
"%s: Allowed PORT bounce LIST",
state->ip_address_str
);
state->interestMask |= INTEREST_PORT_LIST_ALLOWED;
}
if (state->ctrlUsingSec) {
state->terminationCode = SUCCESS_EXIT;
snprintf(
state->terminationDesc,
MAX_STATIC_BUFFER_SIZE,
"%s",
"SUCCESS OK"
);
disconnect_pleasant(bev, state);
}
else {
setup_ending_optional_sec_check(bev, state);
}
break;
case (RESP_EXTRA) :
handle_extra_resp_error(bev, state, "read-port-list-done");
break;
case (RESP_ERROR) :
return;
}
}
char *start_auth(struct in_addr *in, int oport, int iport, char *buf)
{
struct sockaddr_in sin;
int fd, n, Tablesize, len;
fd_set Sockets, sockcheck;
struct timeval t;
char outstr[80];
t.tv_sec = 10L;
t.tv_usec = 0L;
sin.sin_addr.s_addr = in->s_addr;
sin.sin_family = AF_INET;
sin.sin_port = htons(113);
fd = socket(AF_INET, SOCK_STREAM, 0);
if(fd < 0) return((char *)0);
if(connect(fd, (struct sockaddr *)&sin, sizeof(sin)) < 0)
return((char *)0);
FD_ZERO(&Sockets);
FD_SET(fd, &Sockets);
/* Generate request string */
sprintf(outstr, "%d , %d\r\n", oport, iport);
len = strlen(outstr);
Tablesize = getdtablesize();
sockcheck = Sockets;
/* Wait until we can send our request */
if(select(Tablesize, 0, &sockcheck, 0, &t) <= 0)
return((char *)0);
/* Send the request */
n = scwrite(fd, outstr, len);
if(n < len) return((char *)0);
/* Wait until the other side responds */
sockcheck = Sockets;
if(select(Tablesize, &sockcheck, 0, 0, &t) <= 0)
return((char *)0);
/* Read the response */
n = scread(fd, buf, 80);
scclose(fd);
if(n <= 0)
return((char *)0);
else {
buf[n-1] = 0;
parse_response(buf);
return(buf);
}
}
void serve_response() {
int i;
char **response;
if (strcmp(user->type, COMMENT) == 0) {
response = parse_response_and_text(L_CMT_RES);
if (strcmp(response[C_ROOMNAME], user->roomname) != 0)
return;
sprintf(user->buf, "%s: %s\n", response[C_CMT_NICK], response[C_CMT_TEXT]);
show_comment();
} else if (strcmp(user->type, UPLOAD) == 0) {
response = parse_response(L_UPLOAD_RES);
if (strcmp(response[C_ROOMNAME], user->roomname) != 0)
return;
if (strcmp(response[C_UPLOAD_USER], user->username) == 0)
return;
user->download->exist_file = 1;
strcpy(user->download->name, response[C_UPLOAD_FILE]);
sprintf(user->buf, "%s uploads %s\n", response[C_UPLOAD_NICK], response[C_UPLOAD_FILE]);
show_uploadfile();
} else if (strcmp(user->type, DOWNLOAD) == 0) {
response = parse_response(L_DOWNLOAD_RES);
if (strcmp(response[C_DOWNLOAD_STATUS], DOWNLOAD_S) == 0) {
response = parse_response_and_text(L_DOWNLOAD_RES_S);
write(user->download->fd, response[C_DOWNLOAD_TEXT], strlen(response[C_DOWNLOAD_TEXT]));
} else if (strcmp(response[C_DOWNLOAD_STATUS], DOWNLOAD_E) == 0) {
close(user->download->fd);
wclear(room.console);
waddstr(room.console, "Finish downloading.");
wrefresh(room.console);
}
} else if (strcmp(user->type, HISTORY) == 0) {
} else if (strcmp(user->type, ONLINE) == 0) {
wclear(members.win);
response = parse_response(L_ONLINE_RES);
if (strcmp(response[C_ROOMNAME], user->roomname) != 0)
return;
response = parse_response(L_ONLINE_RES);
members.online_num = str_to_int(response[C_MEMBER_NUM]);
response = parse_response(members.online_num);
for (i = 0; i < members.online_num; i++)
show_online_member(response[i]);
response = parse_response(L_ONLINE_RES);
members.offline_num = str_to_int(response[C_MEMBER_NUM]);
response = parse_response(members.offline_num);
for (i = 0; i < members.offline_num; i++)
show_offline_member(response[i]);
} else if (strcmp(user->type, NEWROOM) == 0) {
} else {
printf("Unknown response type: {%s}\n", user->type);
}
wmove(target->win, target->x, target->y);
wrefresh(target->win);
free(response);
}
int mailpop3_quit(mailpop3 * f)
{
char command[POP3_STRING_SIZE];
char * response;
int r;
int res;
if ((f->pop3_state != POP3_STATE_AUTHORIZATION)
&& (f->pop3_state != POP3_STATE_TRANSACTION)) {
res = MAILPOP3_ERROR_BAD_STATE;
goto close;
}
snprintf(command, POP3_STRING_SIZE, "QUIT\r\n");
r = send_command(f, command);
if (r == -1) {
res = MAILPOP3_ERROR_STREAM;
goto close;
}
response = read_line(f);
if (response == NULL) {
res = MAILPOP3_ERROR_STREAM;
goto close;
}
if (parse_response(f, response) == RESPONSE_OK) {
res = MAILPOP3_NO_ERROR;
}
else {
res = MAILPOP3_ERROR_QUIT_FAILED;
}
res = MAILPOP3_NO_ERROR;
close:
if (f->pop3_stream != NULL) {
mailstream_close(f->pop3_stream);
f->pop3_stream = NULL;
}
if (f->pop3_timestamp != NULL) {
free(f->pop3_timestamp);
f->pop3_timestamp = NULL;
}
if (f->pop3_msg_tab != NULL) {
mailpop3_msg_info_tab_free(f->pop3_msg_tab);
f->pop3_msg_tab = NULL;
}
f->pop3_state = POP3_STATE_DISCONNECTED;
return res;
}
