1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifndef __GSUTILITY_H__
#define __GSUTILITY_H__
#include "gsPlatform.h"
#ifdef __cplusplus
extern "C" {
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Async DNS lookup
// async way to resolve a hostname to an IP
typedef struct GSIResolveHostnameInfo * GSIResolveHostnameHandle;
#define GSI_STILL_RESOLVING_HOSTNAME 0
#define GSI_ERROR_RESOLVING_HOSTNAME 0xFFFFFFFF
// start resolving a hostname
// returns 0 on success, -1 on error
int gsiStartResolvingHostname(const char * hostname, GSIResolveHostnameHandle * handle);
// cancel a resolve in progress
void gsiCancelResolvingHostname(GSIResolveHostnameHandle handle);
// returns GSI_STILL_RESOLVING if still resolving the hostname
// returns GSI_ERROR_RESOLVING if it was unable to resolve the hostname
// on success, returns the IP of the host in network byte order
unsigned int gsiGetResolvedIP(GSIResolveHostnameHandle handle);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Get rid of compiler warnings when parameters are never used
// (Mainly used in sample apps and callback for platform switches)
#if (defined(__MWERKS__) && !defined(_NITRO)) || defined(WIN32)
#define GSI_UNUSED(x) x
#elif defined(_PS2) || defined(_NITRO) || defined(_PS3) || defined(_MACOSX)
#define GSI_UNUSED(x) {void* y=&x;y=NULL;}
#elif defined(_PSP)
#define GSI_UNUSED(x) (void)x;
#else
#define GSI_UNUSED(x)
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Cross platform random number generator
void Util_RandSeed(unsigned long seed); // to seed it
int Util_RandInt(int low, int high); // retrieve a random int
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Base 64 encoding (printable characters)
void B64Encode(const char *input, char *output, int inlen, int encodingType);
void B64Decode(const char *input, char *output, int inlen, int * outlen, int encodingType);
// returns the length of the binary data represented by the base64 input string
int B64DecodeLen(const char *input, int encodingType);
typedef struct
{
const char *input;
int len;
int encodingType;
} B64StreamData;
void B64InitEncodeStream(B64StreamData *data, const char *input, int len, int encodingType);
// returns gsi_false if the stream has ended
gsi_bool B64EncodeStream(B64StreamData *data, char output[4]);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#define XXTEA_KEY_SIZE 17
gsi_i8 * gsXxteaEncrypt(const gsi_i8 * iStr, gsi_i32 iLength, gsi_i8 key[XXTEA_KEY_SIZE], gsi_i32 *oLength);
gsi_i8 * gsXxteaDecrypt(const gsi_i8 * iStr, gsi_i32 iLength, gsi_i8 key[XXTEA_KEY_SIZE], gsi_i32 *oLength);
#ifndef max
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
#endif
#if defined(_DEBUG)
void gsiCheckStack(void);
#else
#define gsiCheckStack()
#endif
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// time functions
gsi_time current_time(); // milliseconds
gsi_time current_time_hires(); // microseconds
void msleep(gsi_time msec); // milliseconds
// GSI equivalent of common C-lib time functions
struct tm * gsiSecondsToDate(const time_t *timp); //gmtime
time_t gsiDateToSeconds(struct tm *tb); //mktime
char * gsiSecondsToString(const time_t *timp); //ctime
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Misc utilities
#if defined(_NITRO)
time_t time(time_t *timer);
#define gmtime(t) gsiSecondsToDate(t)
#define ctime(t) gsiSecondsToString(t)
#define mktime(t) gsiDateToSeconds(t)
#elif defined(_REVOLUTION)
time_t gsiTimeInSec(time_t *timer);
struct tm *gsiGetGmTime(time_t *theTime);
char *gsiCTime(time_t *theTime);
#define time(t) gsiTimeInSec(t)
#define gmtime(t) gsiGetGmTime(t)
#define ctime(t) gsiCTime(t)
#else
#include <time.h>
#endif
#ifndef SOMAXCONN
#define SOMAXCONN 5
#endif
typedef const char * (* GetUniqueIDFunction)();
extern GetUniqueIDFunction GOAGetUniqueID;
// Prototypes so the compiler won't warn
#ifdef _PS2
extern int wprintf(const wchar_t*,...);
#endif
// 64-bit Integer reads and writes
gsi_i64 gsiStringToInt64(const char *theNumberStr);
void gsiInt64ToString(char theNumberStr[33], gsi_i64 theNumber);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#ifdef __cplusplus
}
#endif
#endif //__GSUTILITY_H__
|
