github/chiaki
1
0
Fork 0
mirror of https://git.sr.ht/~thestr4ng3r/chiaki synced 2025-08-20 21:43:12 -07:00
Code Issues Projects Releases Packages Wiki Activity Actions

Session Request working

Browse source
This commit is contained in:
Florian Märkl 2018-11-16 21:39:18 +01:00
commit 2fa6ad8b21
No known key found for this signature in database
GPG key ID: 125BC8A5A6A1E857
11 changed files with 263 additions and 33 deletions
Download patch file Download diff file Expand all files Collapse all files

2
lib/include/chiaki/base64.h
View file

@ -28,7 +28,7 @@
extern "C" {
#endif
CHIAKI_EXPORT bool chiaki_base64_decode(const char *in, size_t in_size, uint8_t *out, size_t *out_size);
CHIAKI_EXPORT ChiakiErrorCode chiaki_base64_decode(const char *in, size_t in_size, uint8_t *out, size_t *out_size);
#ifdef __cplusplus
}

3
lib/include/chiaki/common.h
View file

@ -32,7 +32,8 @@ typedef enum
CHIAKI_ERR_THREAD = 2,
CHIAKI_ERR_MEMORY = 3,
CHIAKI_ERR_NETWORK = 4,
CHIAKI_ERR_INVALID_DATA = 5
CHIAKI_ERR_INVALID_DATA = 5,
CHIAKI_ERR_BUF_TOO_SMALL = 6
} ChiakiErrorCode;
CHIAKI_EXPORT const char *chiaki_error_string(ChiakiErrorCode code);

48
lib/include/chiaki/session.h
View file

@ -37,6 +37,37 @@ typedef struct chiaki_connect_info_t
uint8_t morning[0x10];
} ChiakiConnectInfo;
typedef enum {
CHIAKI_QUIT_REASON_NONE,
CHIAKI_QUIT_REASON_SESSION_REQUEST_CONNECTION_REFUSED,
CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN,
CHIAKI_QUIT_REASON_SESSION_REQUEST_RP_IN_USE,
CHIAKI_QUIT_REASON_SESSION_REQUEST_RP_CRASH
} ChiakiQuitReason;
typedef struct chiaki_quit_event_t
{
ChiakiQuitReason reason;
} ChiakiQuitEvent;
typedef enum { CHIAKI_EVENT_QUIT } ChiakiEventType;
typedef struct chiaki_event_t
{
ChiakiEventType type;
union
{
ChiakiQuitEvent quit;
};
} ChiakiEvent;
typedef void (*ChiakiEventCallback)(ChiakiEvent *event, void *user);
#define CHIAKI_KEY_BYTES 0x10
typedef struct chiaki_session_t
{
struct
@ -45,10 +76,17 @@ typedef struct chiaki_session_t
struct addrinfo *host_addrinfo_selected;
char *regist_key;
char *ostype;
char auth[0x10];
uint8_t morning[0x10];
char auth[CHIAKI_KEY_BYTES];
uint8_t morning[CHIAKI_KEY_BYTES];
} connect_info;
uint8_t nonce[CHIAKI_KEY_BYTES];
ChiakiQuitReason quit_reason;
ChiakiEventCallback event_cb;
void *event_cb_user;
ChiakiThread session_thread;
} ChiakiSession;
@ -57,6 +95,12 @@ CHIAKI_EXPORT void chiaki_session_fini(ChiakiSession *session);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_start(ChiakiSession *session);
CHIAKI_EXPORT ChiakiErrorCode chiaki_session_join(ChiakiSession *session);
static inline void chiaki_session_set_event_cb(ChiakiSession *session, ChiakiEventCallback cb, void *user)
{
session->event_cb = cb;
session->event_cb_user = user;
}
#ifdef __cplusplus
}
#endif

12
lib/src/base64.c
View file

@ -40,7 +40,7 @@ static const unsigned char d[] = {
66,66,66,66,66,66
};
CHIAKI_EXPORT bool chiaki_base64_decode(const char *in, size_t in_size, uint8_t *out, size_t *out_size)
CHIAKI_EXPORT ChiakiErrorCode chiaki_base64_decode(const char *in, size_t in_size, uint8_t *out, size_t *out_size)
{
const char *end = in + in_size;
char iter = 0;
@ -56,7 +56,7 @@ CHIAKI_EXPORT bool chiaki_base64_decode(const char *in, size_t in_size, uint8_t
case WHITESPACE:
continue; // skip whitespace
case INVALID:
return false; // invalid input
return CHIAKI_ERR_INVALID_DATA; // invalid input
case EQUALS: // pad character, end of data
in = end;
continue;
@ -67,7 +67,7 @@ CHIAKI_EXPORT bool chiaki_base64_decode(const char *in, size_t in_size, uint8_t
if(iter == 4)
{
if((len += 3) > *out_size)
return false; // buffer overflow
return CHIAKI_ERR_BUF_TOO_SMALL;
*(out++) = (unsigned char)((buf >> 16) & 0xff);
*(out++) = (unsigned char)((buf >> 8) & 0xff);
*(out++) = (unsigned char)(buf & 0xff);
@ -79,17 +79,17 @@ CHIAKI_EXPORT bool chiaki_base64_decode(const char *in, size_t in_size, uint8_t
if(iter == 3)
{
if((len += 2) > *out_size)
return false; // buffer overflow
return CHIAKI_ERR_BUF_TOO_SMALL;
*(out++) = (unsigned char)((buf >> 10) & 0xff);
*(out++) = (unsigned char)((buf >> 2) & 0xff);
}
else if(iter == 2)
{
if(++len > *out_size)
return 1; // buffer overflow
return CHIAKI_ERR_BUF_TOO_SMALL;
*(out++) = (unsigned char)((buf >> 4) & 0xff);
}
*out_size = len;
return true;
return CHIAKI_ERR_SUCCESS;
}

54
lib/src/http.c
View file

@ -35,7 +35,61 @@ CHIAKI_EXPORT void chiaki_http_header_free(ChiakiHttpHeader *header)
CHIAKI_EXPORT ChiakiErrorCode chiaki_http_header_parse(ChiakiHttpHeader **header, char *buf, size_t buf_size)
{
*header = NULL;
#define FAIL(reason) do { chiaki_http_header_free(*header); return (reason); } while(0);
char *key_ptr = buf;
char *value_ptr = NULL;
for(char *end = buf + buf_size; buf<end; buf++)
{
char c = *buf;
if(!c)
break;
if(!value_ptr)
{
if(c == ':')
{
if(key_ptr == buf)
FAIL(CHIAKI_ERR_INVALID_DATA);
*buf = '\0';
buf++;
if(buf == end || *buf != ' ')
FAIL(CHIAKI_ERR_INVALID_DATA);
buf++;
if(buf == end)
FAIL(CHIAKI_ERR_INVALID_DATA);
value_ptr = buf;
}
else if(c == '\r' || c == '\n')
{
if(key_ptr + 1 < buf) // no : encountered yet
FAIL(CHIAKI_ERR_INVALID_DATA);
key_ptr = buf + 1;
}
}
else
{
if(c == '\r' || c == '\n')
{
if(value_ptr == buf) // empty value
FAIL(CHIAKI_ERR_INVALID_DATA);
*buf = '\0';
ChiakiHttpHeader *entry = malloc(sizeof(ChiakiHttpHeader));
if(!entry)
FAIL(CHIAKI_ERR_MEMORY);
entry->key = key_ptr;
entry->value = value_ptr;
entry->next = *header;
*header = entry;
key_ptr = buf + 1;
value_ptr = NULL;
}
}
}
return CHIAKI_ERR_SUCCESS;
#undef FAIL
}
CHIAKI_EXPORT void chiaki_http_response_fini(ChiakiHttpResponse *response)

133
lib/src/session.c
View file

@ -17,18 +17,23 @@
#include <chiaki/session.h>
#include <chiaki/http.h>
#include <chiaki/base64.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <stdbool.h>
#include <errno.h>
#include <sys/socket.h>
#include <netdb.h>
#define SESSION_PORT 9295
#define SESSION_PORT 9295
#define RP_APPLICATION_REASON_IN_USE 0x80108b10
#define RP_APPLICATION_REASON_CRASH 0x80108b15
static void *session_thread_func(void *arg);
@ -38,6 +43,8 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_session_init(ChiakiSession *session, Chiaki
{
memset(session, 0, sizeof(ChiakiSession));
session->quit_reason = CHIAKI_QUIT_REASON_NONE;
int r = getaddrinfo(connect_info->host, NULL, NULL, &session->connect_info.host_addrinfos);
if(r != 0)
{
@ -84,29 +91,81 @@ CHIAKI_EXPORT ChiakiErrorCode chiaki_session_join(ChiakiSession *session)
return chiaki_thread_join(&session->session_thread, NULL);
}
static void session_send_event(ChiakiSession *session, ChiakiEvent *event)
{
if(!session->event_cb)
return;
session->event_cb(event, session->event_cb_user);
}
static ChiakiErrorCode session_thread_request_session(ChiakiSession *session);
static bool session_thread_request_session(ChiakiSession *session);
static void *session_thread_func(void *arg)
{
ChiakiSession *session = arg;
ChiakiErrorCode err;
bool success;
err = session_thread_request_session(session);
if(err != CHIAKI_ERR_SUCCESS)
return NULL;
success = session_thread_request_session(session);
if(!success)
goto quit;
printf("Connected!\n");
ChiakiEvent quit_event;
quit:
quit_event.type = CHIAKI_EVENT_QUIT;
quit_event.quit.reason = session->quit_reason;
session_send_event(session, &quit_event);
return NULL;
}
static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
typedef struct session_response_t {
uint32_t error_code;
const char *nonce;
const char *rp_version;
bool success;
} SessionResponse;
static void parse_session_response(SessionResponse *response, ChiakiHttpResponse *http_response)
{
memset(response, 0, sizeof(SessionResponse));
if(http_response->code == 200)
{
for(ChiakiHttpHeader *header=http_response->headers; header; header=header->next)
{
if(strcmp(header->key, "RP-Nonce") == 0)
response->nonce = header->value;
else if(strcmp(header->key, "RP-Version") == 0)
response->rp_version = header->value;
}
response->success = response->nonce != NULL;
}
else
{
for(ChiakiHttpHeader *header=http_response->headers; header; header=header->next)
{
if(strcmp(header->key, "RP-Application-Reason") == 0)
response->error_code = (uint32_t)strtol(header->value, NULL, 0x10);
}
response->success = false;
}
}
static bool session_thread_request_session(ChiakiSession *session)
{
int session_sock = -1;
char host_buf[128];
for(struct addrinfo *ai=session->connect_info.host_addrinfos; ai; ai=ai->ai_next)
{
if(ai->ai_protocol != IPPROTO_TCP)
continue;
struct sockaddr *sa = malloc(ai->ai_addrlen);
if(!sa)
continue;
@ -135,6 +194,10 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
r = connect(session_sock, sa, ai->ai_addrlen);
if(r < 0)
{
if(errno == ECONNREFUSED)
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_CONNECTION_REFUSED;
else
session->quit_reason = CHIAKI_QUIT_REASON_NONE;
close(session_sock);
session_sock = -1;
free(sa);
@ -150,12 +213,13 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
if(session_sock < 0)
{
printf("Session Connection Failed.\n");
return CHIAKI_ERR_NETWORK;
if(session->quit_reason == CHIAKI_QUIT_REASON_NONE)
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
return false;
}
printf("Connected to %s:%u\n", host_buf, SESSION_PORT);
static const char session_request_fmt[] =
"GET /sce/rp/session HTTP/1.1\r\n"
"Host: %s:%d\r\n"
@ -171,9 +235,9 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
host_buf, SESSION_PORT, session->connect_info.regist_key);
if(request_len < 0 || request_len >= sizeof(buf))
{
printf("Session Request Building Failed.\n");
close(session_sock);
return CHIAKI_ERR_MEMORY;
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
return false;
}
printf("sending\n%s\n", buf);
@ -181,10 +245,9 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
ssize_t sent = send(session_sock, buf, (size_t)request_len, 0);
if(sent < 0)
{
printf("Session Request Send Failed.\n");
perror("send");
close(session_sock);
return CHIAKI_ERR_NETWORK;
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
return false;
}
size_t header_size;
@ -193,21 +256,53 @@ static ChiakiErrorCode session_thread_request_session(ChiakiSession *session)
if(err != CHIAKI_ERR_SUCCESS)
{
close(session_sock);
return err;
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
return false;
}
buf[received_size] = '\0';
printf("received\n%s\n", buf);
ChiakiHttpResponse response;
err = chiaki_http_response_parse(&response, buf, header_size);
ChiakiHttpResponse http_response;
err = chiaki_http_response_parse(&http_response, buf, header_size);
if(err != CHIAKI_ERR_SUCCESS)
{
close(session_sock);
return err;
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
return false;
}
SessionResponse response;
parse_session_response(&response, &http_response);
if(response.success)
{
size_t nonce_len = CHIAKI_KEY_BYTES;
err = chiaki_base64_decode(response.nonce, strlen(response.nonce), session->nonce, &nonce_len);
if(err != CHIAKI_ERR_SUCCESS || nonce_len != CHIAKI_KEY_BYTES)
{
response.success = false;
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
}
}
else
{
switch(response.error_code)
{
case RP_APPLICATION_REASON_IN_USE:
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_RP_IN_USE;
break;
case RP_APPLICATION_REASON_CRASH:
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_RP_CRASH;
break;
default:
session->quit_reason = CHIAKI_QUIT_REASON_SESSION_REQUEST_UNKNOWN;
break;
}
}
chiaki_http_response_fini(&http_response);
close(session_sock);
return CHIAKI_ERR_SUCCESS;
return response.success;
}