void port_read_line(port_t *port, string_t *s)
{
char ch;
string_set(s, "");
assert(port_is_input(port));
if (port_is_input(port))
{
for (;;)
{
ch = port_read_char(port);
/* Line break on \r or \n or \r\n and consume the line break character(s) */
if (ch == '\r')
{
ch = port_peek_char(port);
if (ch == '\n')
ch = port_read_char(port);
break;
}
else if (ch == '\n' || ch == EOF)
break;
string_nappend(s, &ch, 1);
}
}
}
void string_append(string_t *str, cptr val)
{
if (!val)
return;
string_nappend(str, val, strlen(val));
}
STRING *string_append(STRING *str, CHAR *newstr)
{
if(newstr)
{
return string_nappend(str, newstr, strlen(newstr));
}
return str;
}
BOOL buffer_fetch_STRING(BUFFER *buf, BYTE **ptr, STRING **pstr, INT len)
{
BYTE *p = *ptr;
if(!buffer_has_data(buf, p, len))
return FALSE;
*pstr = string_nappend(NULL, (CHAR *)p, len);
BUF_ROLL(p, len);
*ptr = p;
return TRUE;
}
BOOL socket_fetch_STRING(SOCKET sock, BUFFER *buf, BYTE **ptr, STRING **pstr, INT len1)
{
int len;
BYTE tmpbuf[1024];
BYTE *p = *ptr;
while (!buffer_has_data(buf, p, len1)) {
len = os_socket_tcp_recv_nonblock(sock, tmpbuf, sizeof(tmpbuf));
buffer_append(buf, tmpbuf, len);
}
*pstr = string_nappend(NULL, (CHAR *)p, len1);
BUF_ROLL(p, len1);
*ptr = p;
return TRUE;
}
void port_write_char(port_t *port, char ch)
{
assert(port_is_output(port));
if (port_is_output(port))
{
switch (port->tag)
{
case _PORT_STRING:
string_nappend(port->data.string_port.buf, &ch, 1);
break;
case _PORT_FILE:
case _PORT_FILE_STD:
fputc(ch, port->data.file_port.file);
break;
}
}
}
void port_read_until(port_t *port, string_t *s, char_predicate_fn f)
{
char ch;
string_set(s, "");
assert(port_is_input(port));
if (port_is_input(port))
{
for (;;)
{
ch = port_peek_char(port);
if (ch == EOF || f(ch))
break;
ch = port_read_char(port);
string_nappend(s, &ch, 1);
}
}
}
INT setting_get_key_value(CHAR *valueptr, STRING *str)
{
CHAR *p, *p1;
INT valuelen;
p = valueptr;
if(!p || !str) return 0;
p1 = strchr(p, '\n');
if(!p1)
valuelen = strlen(p);
else
valuelen = p1 - p;
//str = string_assign(str, p);
//string_truncate(str, valuelen);
string_truncate(str, 0);
string_nappend(str, p, valuelen);
return valuelen;
}
static int read_data(client_t *client)
{
char buffer[1025];
int n;
n = read(client->fd, buffer, 1024);
if (n == 0) {
musicd_log(LOG_INFO, "client", "%s: exiting", client->address);
return -1;
}
if (n < 0) {
if (errno == EWOULDBLOCK) {
/* No data available right now, ignore */
return 0;
}
musicd_perror(LOG_INFO, "client", "%s: can't read", client->address);
return -1;
}
string_nappend(client->inbuf, buffer, n);
return n;
}
int client_write(client_t *client, const char *data, size_t n)
{
string_nappend(client->outbuf, data, n);
return n;
}
int tunet_keepalive()
{
BYTE tmpbuf[1024];
BYTE repbuf[9];
CHAR tmp[1024];
BYTE *p;
BYTE btag;
BYTE data[16];
CHAR smoney[255];
des_context ctx;
int len;
UINT32 uint_used_money, uint_money;
STRING *str = NULL;
// BOOL sr, sw, se;
if(!keepalive_socket) return OK;
// os_socket_tcp_status(keepalive_socket, &sr, &sw, &se);
if(tunet_state != TUNET_STATE_KEEPALIVE){
// printf("state error\n");
return OK;
}
/* if(se)
{
logs_append(g_logs, "TUNET_NETWORK_ERROR", "KEEPALIVE", NULL, 0);
return ERR;
}
if(!sr) return OK;
*/
// printf("start recv.\n");
len = os_socket_tcp_recv(keepalive_socket, tmpbuf, sizeof(tmpbuf));
// printf("finished recv.\n");
if(len == -1)
{
logs_append(g_logs, "TUNET_NETWORK_ERROR", "KEEPALIVE", NULL, 0);
return ERR;
}
if(len > 0)
{
keepalive_socket_buffer = buffer_append(keepalive_socket_buffer, tmpbuf, len);
buf2output(tmpbuf, len, tmp, 16);
//dprintf("data received(keepalive):\n%s\n", tmp);
logs_append(g_logs, "TUNET_KEEPALIVE_RECV", NULL, tmpbuf, len);
p = keepalive_socket_buffer->data;
while(buffer_fetch_BYTE(keepalive_socket_buffer, &p, &btag))
{
switch(btag)
{
case 0x03:
if(!buffer_fetch_bytes(keepalive_socket_buffer, &p, data, 16))
return OK;
logs_append(g_logs, "TUNET_KEEPALIVE_CONFIRM", NULL, NULL, 0);
uint_used_money = htonl(BUFDWORD( (data + 8) ));
uint_money = htonl(BUFDWORD( (data + 12) ));
des_set_key(&ctx, (uint8 *)keepalive_key);
des_encrypt(&ctx, (uint8 *)data, (uint8 *)(repbuf + 1));
repbuf[0] = 0x02;
os_socket_tcp_send(keepalive_socket, repbuf, sizeof(repbuf));
keepalive_socket_buffer = buffer_rollto(keepalive_socket_buffer, p);
p = keepalive_socket_buffer->data;
os_tick_clear(keepalive_timeout);
snprintf(smoney, sizeof(smoney), "%0.2f", tunet_imoney_to_fmoney(uint_money));
logs_append(g_logs, "TUNET_KEEPALIVE_MONEY", smoney, NULL, 0);
snprintf(smoney, sizeof(smoney), "%0.2f", tunet_imoney_to_fmoney(uint_used_money));
logs_append(g_logs, "TUNET_KEEPALIVE_USED_MONEY", smoney, NULL, 0);
break;
case 0xff://ff 53 65 72 76 69 63 65 20 54 65 72 6d 69 6e 61 74 65 64 21 0d 0a
tunet_state = TUNET_STATE_ERROR;
str = string_nappend(str, (CHAR *)(keepalive_socket_buffer->data + 1), keepalive_socket_buffer->len - 1);
logs_append(g_logs, "TUNET_KEEPALIVE_ERROR", str->str, NULL, 0);
str = string_free(str);
keepalive_socket_buffer = buffer_clear(keepalive_socket_buffer);
break;
default:
tunet_state = TUNET_STATE_ERROR;
logs_append(g_logs, "TUNET_KEEPALIVE_RECV_UNKNOWN", NULL, NULL, 0);
//dprintf("%s\n", "意外的标记");
break;
}
}
}
return OK;
}
static int tunet_logon_recv_welcome()
{
BYTE tmpbuf[1024 * 8];
CHAR tmp[1024];
BYTE btag;
UINT32 unknowntag;
UINT32 datalen;
BYTE *p;
int len;
const CHAR *WELCOME = "WELCOME TO TUNET";
//int msglen = 0;
STRING *str = NULL;
// BOOL sr, sw, se;
if(!main_socket) return OK;
// os_socket_tcp_status(main_socket, &sr, &sw, &se);
if(tunet_state != TUNET_STATE_RECV_WELCOME)
return OK;
/* if(se)
{
logs_append(g_logs, "TUNET_NETWORK_ERROR", "RECV_WELCOME", NULL, 0);
return ERR;
}
if(!sr) return OK;
*/
len = os_socket_tcp_recv(main_socket, tmpbuf, sizeof(tmpbuf));
if(len == -1)
{
logs_append(g_logs, "TUNET_NETWORK_ERROR", "RECV_WELCOME", NULL, 0);
return ERR;
}
if(len > 0)
{
main_socket_buffer = buffer_append(main_socket_buffer, tmpbuf, len);
logs_append(g_logs, "TUNET_LOGON_RECV", "WELCOME", tmpbuf, len);
buf2output(tmpbuf, len, tmp, 16);
//dprintf("data received(recv welcome):\n%s\n", tmp);
p = main_socket_buffer->data;
while(buffer_fetch_BYTE(main_socket_buffer, &p, &btag))
{
switch(btag)
{
case 0x01:
if(!buffer_fetch_STRING(main_socket_buffer, &p, &str, strlen(WELCOME)))
return OK;
if(strncmp(str->str, WELCOME, strlen(WELCOME)) != 0)
{
str = string_free(str);
//TODO
//process such error!!!!!!!!!
logs_append(g_logs, "TUNET_LOGON_WELCOME", str->str, NULL, 0);
tunet_state = TUNET_STATE_ERROR;
return OK;
}
str = string_free(str);
if(!buffer_fetch_DWORD(main_socket_buffer, &p, &unknowntag))
return OK;
unknowntag = htonl(unknowntag);
if(!buffer_fetch_bytes(main_socket_buffer, &p, welcome_data, 8))
return OK;
if(!buffer_fetch_DWORD(main_socket_buffer, &p, &datalen))
return OK;
datalen = htonl(datalen);
//dprintf("欢迎消息长 %d\n", datalen);
if(!buffer_fetch_STRING(main_socket_buffer, &p, &str, datalen))
return OK;
logs_append(g_logs, "TUNET_LOGON_WELCOME", str->str, NULL, 0);
//dprintf("%s\n", str->str);
str = string_free(str);
main_socket_buffer = buffer_rollto(main_socket_buffer, p);
p = main_socket_buffer->data;
tunet_state = TUNET_STATE_REPLY_WELCOME;
break;
case 0x02:
case 0x05:
datalen = htonl(BUF_FETCH_DWORD(p));
//dprintf("出错消息长 %d\n", datalen);
str = string_new("");
str = string_nappend(str, (CHAR *)p, datalen);
//dprintf("%s\n", str->str);
tunet_state = TUNET_STATE_ERROR;
logs_append(g_logs, "TUNET_LOGON_ERROR", str->str, NULL, 0);
str = string_free(str);
BUF_ROLL(p, datalen);
main_socket_buffer = buffer_rollto(main_socket_buffer, p);
p = main_socket_buffer->data;
break;
}
}
}
return OK;
}
