guint
save_up(gpointer data)
{
FILE *fr;
guint res = 0;
gchar *feed_dir, *feed_name, *user, *pass;
gchar *tmp = gen_md5(data);
gchar *buf = g_strconcat(tmp, ".rec", NULL);
g_free(tmp);
feed_dir = rss_component_peek_base_directory();
if (!g_file_test(feed_dir, G_FILE_TEST_EXISTS))
g_mkdir_with_parents (feed_dir, 0755);
feed_name = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", feed_dir, buf);
g_free(feed_dir);
fr = fopen(feed_name, "w+");
if (fr) {
user = g_hash_table_lookup(rf->hruser, data);
fputs(user, fr);
fputs("\n", fr);
pass = g_hash_table_lookup(rf->hrpass, data);
fputs(pass, fr);
fclose(fr);
res = 1;
}
g_free(feed_name);
g_free(buf);
return res;
}
guint
del_up(gpointer data)
{
gchar *feed_dir, *feed_name;
gchar *tmp = gen_md5(data);
gchar *buf = g_strconcat(tmp, ".rec", NULL);
g_free(tmp);
feed_dir = rss_component_peek_base_directory();
if (!g_file_test(feed_dir, G_FILE_TEST_EXISTS))
g_mkdir_with_parents (feed_dir, 0755);
feed_name = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s", feed_dir, buf);
g_free(feed_dir);
unlink(feed_name);
g_free(feed_name);
g_free(buf);
return 0;
}
guint
read_up(gpointer data)
{
FILE *fr;
char rfeed[512];
guint res = 0;
gchar *tmp, *buf, *feed_dir, *feed_name;
if (NULL != g_hash_table_lookup(rf->hruser, data))
return 1;
tmp = gen_md5(data);
buf = g_strconcat(tmp, ".rec", NULL);
g_free(tmp);
feed_dir = rss_component_peek_base_directory();
if (!g_file_test(feed_dir, G_FILE_TEST_EXISTS))
g_mkdir_with_parents (feed_dir, 0755);
feed_name = g_build_path(G_DIR_SEPARATOR_S, feed_dir, buf, NULL);
g_free(feed_dir);
d("reading auth info:%s\n", feed_name);
fr = fopen(feed_name, "r");
if (fr) {
fgets(rfeed, 511, fr);
g_hash_table_insert(
rf->hruser, data, g_strstrip(g_strdup(rfeed)));
fgets(rfeed, 511, fr);
g_hash_table_insert(
rf->hrpass, data, g_strstrip(g_strdup(rfeed)));
fclose(fr);
res = 1;
}
g_free(feed_name);
g_free(buf);
return res;
}
ws_ctx_t *do_handshake(int sock) {
char handshake[4096], response[4096], sha1[29], trailer[17];
char *scheme, *pre;
headers_t *headers;
int len, ret, i, offset;
ws_ctx_t * ws_ctx;
// Peek, but don't read the data
len = recv(sock, handshake, 1024, MSG_PEEK);
handshake[len] = 0;
if (len == 0) {
handler_msg("ignoring empty handshake\n");
return NULL;
} else if (bcmp(handshake, "<policy-file-request/>", 22) == 0) {
len = recv(sock, handshake, 1024, 0);
handshake[len] = 0;
handler_msg("sending flash policy response\n");
send(sock, POLICY_RESPONSE, sizeof(POLICY_RESPONSE), 0);
return NULL;
} else if ((bcmp(handshake, "\x16", 1) == 0) ||
(bcmp(handshake, "\x80", 1) == 0)) {
// SSL
if (!settings.cert) {
handler_msg("SSL connection but no cert specified\n");
return NULL;
} else if (access(settings.cert, R_OK) != 0) {
handler_msg("SSL connection but '%s' not found\n",
settings.cert);
return NULL;
}
ws_ctx = alloc_ws_ctx();
ws_socket_ssl(ws_ctx, sock, settings.cert, settings.key);
if (! ws_ctx) { return NULL; }
scheme = "wss";
handler_msg("using SSL socket\n");
} else if (settings.ssl_only) {
handler_msg("non-SSL connection disallowed\n");
return NULL;
} else {
ws_ctx = alloc_ws_ctx();
ws_socket(ws_ctx, sock);
if (! ws_ctx) { return NULL; }
scheme = "ws";
handler_msg("using plain (not SSL) socket\n");
}
offset = 0;
for (i = 0; i < 10; i++) {
len = ws_recv(ws_ctx, handshake+offset, 4096);
if (len == 0) {
handler_emsg("Client closed during handshake\n");
return NULL;
}
offset += len;
handshake[offset] = 0;
if (strstr(handshake, "\r\n\r\n")) {
break;
}
usleep(10);
}
//handler_msg("handshake: %s\n", handshake);
if (!parse_handshake(ws_ctx, handshake)) {
handler_emsg("Invalid WS request\n");
return NULL;
}
headers = ws_ctx->headers;
if (ws_ctx->hybi > 0) {
handler_msg("using protocol HyBi/IETF 6455 %d\n", ws_ctx->hybi);
gen_sha1(headers, sha1);
sprintf(response, SERVER_HANDSHAKE_HYBI, sha1, "base64");
} else {
if (ws_ctx->hixie == 76) {
handler_msg("using protocol Hixie 76\n");
gen_md5(headers, trailer);
pre = "Sec-";
} else {
handler_msg("using protocol Hixie 75\n");
trailer[0] = '\0';
pre = "";
}
sprintf(response, SERVER_HANDSHAKE_HIXIE, pre, headers->origin, pre, scheme,
headers->host, headers->path, pre, "base64", trailer);
}
//handler_msg("response: %s\n", response);
ws_send(ws_ctx, response, strlen(response));
return ws_ctx;
}
ws_ctx_t *do_handshake(int sock, bool* useHixie) {
char handshake[4096], response[4096], trailer[17], hashDataB64[256];
char *scheme, *pre;
headers_t headers;
int len, i;
u_char hashTemp[5];
ws_ctx_t * ws_ctx;
SHA1Context sha1context;
ws_ctx = ws_socket(sock);
// Peek, but don't read the data
len = ws_recv(ws_ctx, handshake, 1024);
if (len < 1)
{
handler_msg("recv error %d in do_handshake\n", WSAGetLastError());
}
handshake[len] = 0;
if (len == 0) {
handler_msg("ignoring empty handshake\n");
return NULL;
} else if (bcmp(handshake, "<policy-file-request/>", 22) == 0) {
handshake[len] = 0;
handler_msg("sending flash policy response\n");
send(sock, policy_response, sizeof(policy_response) - 1, 0);
return NULL;
} else if ((bcmp(handshake, "\x16", 1) == 0) ||
(bcmp(handshake, "\x80", 1) == 0)) {
// SSL
if (!settings.cert) {
handler_msg("SSL connection but no cert specified\n");
return NULL;
} else if (access(settings.cert, R_OK) != 0) {
handler_msg("SSL connection but '%s' not found\n",
settings.cert);
return NULL;
}
//ws_ctx = ws_socket_ssl(sock, settings.cert, settings.key);
if (! ws_ctx) { return NULL; }
scheme = "wss";
handler_msg("using SSL socket\n");
} else if (settings.ssl_only) {
handler_msg("non-SSL connection disallowed\n");
return NULL;
} else {
ws_ctx = ws_socket(sock);
if (! ws_ctx) { return NULL; }
scheme = "ws";
handler_msg("using plain (not SSL) socket\n");
}
//len = ws_recv(ws_ctx, handshake, 4096);
if (len == 0) {
handler_emsg("Client closed during handshake\n");
return NULL;
}
else if (len == -1)
{
return ws_ctx;
}
handshake[len] = 0;
if (!parse_handshake(handshake, &headers)) {
handler_emsg("Invalid WS request\n");
return NULL;
}
if (headers.version[0] != '\0')
{
//strcpy((char*)headers.key1, (const char *)"dGhlIHNhbXBsZSBub25jZQ==");
strncat(headers.key1, websocket_GUID, strlen(websocket_GUID));
SHA1Reset(&sha1context);
//sha1context.Length_High = 0;
//sha1context.Length_Low = strlen(headers.key1);
SHA1Input(&sha1context, (const unsigned char*)&(headers.key1), strlen(headers.key1));
SHA1Result(&sha1context);
for (i = 0; i < 5; i++)
{
hashTemp[i * 4] = ((u_char*)sha1context.Message_Digest)[i * 4 + 3];
hashTemp[i * 4 + 1] = ((u_char*)sha1context.Message_Digest)[i * 4 + 2];
hashTemp[i * 4 + 2] = ((u_char*)sha1context.Message_Digest)[i * 4 + 1];
hashTemp[i * 4 + 3] = ((u_char*)sha1context.Message_Digest)[i * 4];
}
b64_ntop((const u_char*)&hashTemp, 5 * sizeof(int), (char*)&hashDataB64, 256);
//b64_pton((const char*)sha1context.Message_Digest, (u_char*)&hashDataB64, 256);
sprintf(response, server_handshake_hybi, headers.upgrade, headers.connection, hashDataB64);
handler_msg("response: %s\n", response);
ws_send(ws_ctx, response, strlen(response));
*useHixie = FALSE;
return ws_ctx;
}
if (headers.key3[0] != '\0') {
gen_md5(&headers, trailer);
pre = "Sec-";
handler_msg("using protocol version 76\n");
} else {
trailer[0] = '\0';
pre = "";
handler_msg("using protocol version 75\n");
}
sprintf(response, server_handshake, pre, headers.origin, pre, scheme,
headers.host, headers.path, "", trailer);
handler_msg("response: %s\n", response);
ws_send(ws_ctx, response, strlen(response));
return ws_ctx;
}
