/* url decodes the contents of buf, and places the decoded version back in buf
Returns buf, or NULL on error */
char *url_decode(char *buf) {
char *ptr = buf;
int i;
int c = 0, c2;
int state = TEXT;
for(i = 0; *ptr; ptr++) {
switch(state) {
case TEXT:
if(*ptr == '%') state = HEX1;
else buf[i++] = *ptr;
break;
case HEX1:
/* convert to a value and put in c */
if((c = hex_to_digit(*ptr)) < 0) return NULL;
state = HEX2;
break;
case HEX2:
/* convert to a value, put in c2, and add the character */
if((c2 = hex_to_digit(*ptr)) < 0) return NULL;
buf[i++] = (c << 4) | c2;
state = TEXT;
break;
}
}
buf[i] = '\0';
return buf;
}
char * do_hash( char * sec_ws_key )
{
#if 0
strcpy( sec_ws_key, "wTfhMBsUmc9/v6RWgzmLiw==" );
/* expected: TyRLRl5fE8awKtbv4EQl5GSWfcE= */
#endif
SHA1Context sha;
SHA1Reset( &sha );
char * combined = (char *)calloc( 1 + strlen( sec_ws_key ) + strlen( GUID ), sizeof( char ) );
sprintf( combined, "%s%s", sec_ws_key, GUID );
printf( "HASHING: [%s]\n", combined );
SHA1Input( &sha, (const unsigned char *)combined, strlen( combined ) );
if ( SHA1Result( &sha ) )
{
char * result = (char *)calloc( 128, sizeof( char ) );
result[0] = '\0';
int i, j;
for ( i = 0, j = 0 ; i < 5 ; i++ )
{
int k;
char mini[16];
sprintf( mini, "%08X", sha.Message_Digest[i] ); /* e.g. 99AABBCC */
for ( k = 0 ; k < 8 ; k += 2 )
{
result[j++] = hex_to_digit( mini[k] ) * 16 + hex_to_digit( mini[k+1] );
}
}
int output_length = 28;
char * x = encode_base64( 20, (unsigned char *)result );
strncpy( result, x, output_length );
result[ output_length ] = '\0';
return result;
}
else
{
printf( "Error performing do_hash() function\n" );
return (char *)NULL;
}
}
// Probably a void function, but sometimes returns a useful-ish value.
int sceNetEtherStrton(u32 bufferPtr, u32 macPtr) {
DEBUG_LOG(SCENET, "sceNetEtherStrton(%08x, %08x)", bufferPtr, macPtr);
if (Memory::IsValidAddress(bufferPtr) && Memory::IsValidAddress(macPtr)) {
const char *buffer = (char *)Memory::GetPointer(bufferPtr);
u8 *mac = Memory::GetPointer(macPtr);
// MAC address is always 6 pairs of hex digits.
// TODO: Funny stuff happens if it's too short.
u8 value = 0;
for (int i = 0; i < 6 && *buffer != 0; ++i) {
value = 0;
int c = hex_to_digit(*buffer++);
if (c != -1) {
value |= c << 4;
}
c = hex_to_digit(*buffer++);
if (c != -1) {
value |= c;
}
*mac++ = value;
// Skip a single character in between.
// TODO: Strange behavior on the PSP, let's just null check.
if (*buffer++ == 0) {
break;
}
}
// Seems to maybe kinda return the last value. Probably returns void.
return value;
} else {
// Possibly a void function, seems to return this on bad args (or crash.)
return 0;
}
}
void uart_rx_worker(void *parg)
{
uart_config_t *uart = (uart_config_t *) parg;
while(true)
{
pop_front(&uart->rx_queue, uart->rx_worker_buffer, INDEFINITE_WAIT);
if((uart->flags & NMEA_DECODER_ENABLE) != 0)
{
char *start = (char *) uart->rx_worker_buffer;
char *end = start;
uint8_t sentence = 0;
uint8_t word = 0;
uint8_t checksum = 0;
bool checksum_marker = false;
// calculate the checksum of the string
while(*start != 0 && *start != '*')
checksum ^= *start++;
start = end;
while(*start != 0)
{
if(checksum_marker) // checksum marker
{
// compare the checksum
uint8_t chk = 0;
if(is_alphanum(start[0]) &&
is_alphanum(start[1]) &&
start[2] == 0)
{
chk = hex_to_digit(start[0]) << 4;
chk += hex_to_digit(start[1]);
}
(uart->callback.nmea_callback)(uart,
checksum != chk ? 0 : (char *) 1,
sentence, word);
start++;
break; // and done, wait for next
}
for(end = start; *end != 0 && *end != ',' && *end != '*' ; end++);
if(*end == '*')
checksum_marker = true;
*end = 0;
sentence = (uart->callback.nmea_callback)(uart, start, sentence, word);
word++;
// skip token
start = end;
// and increment to next word
start++;
}
}
else
(uart->callback.uart_callback)(uart, uart->rx_worker_buffer, strlen((const char *)uart->rx_worker_buffer));
}
}
