YourWishes/dusk
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

PSP net code first pass

Browse Source
This commit is contained in:
Dominic Masters
2026-04-15 15:50:43 -05:00
parent 133685ea37
commit e51cdc8992
12 changed files with 611 additions and 16 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cmake/targets/psp.cmake
+6
View File
@@ -24,6 +24,11 @@ target_link_libraries(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
pspvfpu
pspvram
psphprm
pspnet
pspnet_inet
pspnet_apctl
psphttp
pspssl
)
target_include_directories(${DUSK_LIBRARY_TARGET_NAME} PRIVATE
@@ -39,6 +44,7 @@ target_compile_definitions(${DUSK_LIBRARY_TARGET_NAME} PUBLIC
DUSK_OPENGL_LEGACY
DUSK_DISPLAY_WIDTH=480
DUSK_DISPLAY_HEIGHT=272
THREAD_PTHREAD=1
)
# Postbuild, create .pbp file for PSP.
src/dusk/engine/engine.c
+16 -11
View File
@@ -28,12 +28,9 @@
engine_t ENGINE;
/* Kept module-level only because engineUpdate needs them for the reset. */
static entityid_t phBoxEnt;
static componentid_t phBoxPhys;
/* ---- test network callbacks ---- */
static void onTestResponse(
const uint16_t status,
const char_t *body,
@@ -48,6 +45,21 @@ static void onTestError(errorret_t error, void *user) {
printf("HTTP error: %s\n", error.state->message);
}
static void onNetworkConnected(void *user) {
printf("Network connected.\n");
networkHTTPRequest(
"http://10.0.0.94:3000/test",
NETWORK_HTTP_REQUEST_METHOD_GET,
NULL, NULL, 0, NULL,
onTestResponse,
onTestError
);
}
static void onNetworkFailed(errorret_t error, void *user) {
printf("Network connection failed: %s\n", error.state->message);
}
errorret_t engineInit(const int32_t argc, const char_t **argv) {
memoryZero(&ENGINE, sizeof(engine_t));
ENGINE.running = true;
@@ -66,16 +78,9 @@ errorret_t engineInit(const int32_t argc, const char_t **argv) {
entityManagerInit();
physicsManagerInit();
errorChain(networkManagerInit());
networkManagerRequestConnection(onNetworkConnected, onNetworkFailed, NULL);
errorChain(gameInit());
networkHTTPRequest(
"http://localhost:3000/test",
NETWORK_HTTP_REQUEST_METHOD_GET,
NULL, NULL, 0, NULL,
onTestResponse,
onTestError
);
/* ---- Camera ---- */
entityid_t cam = entityManagerAdd();
componentid_t camPos = entityAddComponent(cam, COMPONENT_TYPE_POSITION);
src/dusk/network/networkmanager.c
+12
View File
@@ -22,6 +22,18 @@ errorret_t networkManagerUpdate() {
errorOk();
}
bool_t networkManagerIsConnected() {
return networkPlatformIsConnected();
}
void networkManagerRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
) {
networkPlatformRequestConnection(onConnected, onFailed, user);
}
errorret_t networkManagerDispose() {
errorChain(networkPlatformDispose());
errorOk();
src/dusk/network/networkmanager.h
+39
View File
@@ -29,6 +29,45 @@ errorret_t networkManagerInit();
*/
errorret_t networkManagerUpdate();
/**
* Returns true if the system is connected to AN network, this doesn't mean that
* requests will succeed, doesn't mean there's internet, just that we could
* possibly make network requests. If this is false, this usually means
* something like;
* - A network cable is not connnected
* - No Wi-Fi Connection has been established
* - No IP Address has been assigned
*
* That kinda stuff.
*
* In future I will probably have REASONS for why it's not connected, for
* example;
* - On PSP you need to "request" network access
* - On GameCube, network settings need to be defined, including DHCP, etc.
* - On Windows, this may require additional permissions
*
* @return True if some network connection is detected.
*/
bool_t networkManagerIsConnected();
/**
* See networkManagerIsConnected for a bit more info, but this is for some
* platforms (mainly PSP) to request the system to start doing networking.
*
* You should only call this once and assume that it is "pending" until either
* onComplete or onFailed is invoked. If you call this twice it is undefined
* behavior.
*
* @param onConnected Callback to invoke when the network is connected.
* @param onFailed Callback to invoke if the network connection fails.
* @param user User data to pass to the callbacks.
*/
void networkManagerRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
);
/**
* Disposes of the network manager. This will NOT disconnect from the network.
*
src/dusklinux/network/networklinux.c
+14
View File
@@ -190,6 +190,20 @@ errorret_t networkLinuxUpdate() {
errorOk();
}
bool_t networkLinuxIsConnected() {
return true;
}
void networkLinuxRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
) {
assertNotNull(onConnected, "onConnected must not be NULL");
assertNotNull(onFailed, "onFailed must not be NULL");
onConnected(user);
}
errorret_t networkLinuxDispose() {
curl_global_cleanup();
threadMutexDispose(&NETWORK_LINUX.resultsMutex);
src/dusklinux/network/networklinux.h
+22 -2
View File
@@ -59,14 +59,34 @@ errorret_t networkLinuxInit();
/**
* Updates the network manager, called once per frame to handle completed
* HTTP requests.
*
*
* @return Any error that occurs.
*/
errorret_t networkLinuxUpdate();
/**
* Returns true — Linux uses the OS network stack which is always available.
*
* @return true
*/
bool_t networkLinuxIsConnected();
/**
* No-op — Linux connection is managed by the OS. Calls onConnected immediately.
*
* @param onConnected Callback invoked immediately.
* @param onFailed Unused.
* @param user Passed to onConnected.
*/
void networkLinuxRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
);
/**
* Disposes the network manager.
*
*
* @return Any error that occurs.
*/
errorret_t networkLinuxDispose();
src/dusklinux/network/networkplatform.h
+4 -2
View File
@@ -8,7 +8,9 @@
#pragma once
#include "networklinux.h"
#define networkPlatformInit networkLinuxInit
#define networkPlatformUpdate networkLinuxUpdate
#define networkPlatformInit networkLinuxInit
#define networkPlatformUpdate networkLinuxUpdate
#define networkPlatformDispose networkLinuxDispose
#define networkPlatformIsConnected networkLinuxIsConnected
#define networkPlatformRequestConnection networkLinuxRequestConnection
#define networkPlatformHTTPRequest networkLinuxHTTPRequest
src/duskpsp/CMakeLists.txt
+2 -1
View File
@@ -17,4 +17,5 @@ target_sources(${DUSK_BINARY_TARGET_NAME}
# Subdirs
add_subdirectory(asset)
add_subdirectory(input)
add_subdirectory(log)
add_subdirectory(log)
add_subdirectory(network)
src/duskpsp/network/CMakeLists.txt
+9
View File
@@ -0,0 +1,9 @@
# Copyright (c) 2026 Dominic Masters
#
# This software is released under the MIT License.
# https://opensource.org/licenses/MIT
target_sources(${DUSK_LIBRARY_TARGET_NAME}
PUBLIC
networkpsp.c
)
src/duskpsp/network/networkplatform.h
+16
View File
@@ -0,0 +1,16 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "networkpsp.h"
#define networkPlatformInit networkPspInit
#define networkPlatformUpdate networkPspUpdate
#define networkPlatformDispose networkPspDispose
#define networkPlatformIsConnected networkPspIsConnected
#define networkPlatformRequestConnection networkPspRequestConnection
#define networkPlatformHTTPRequest networkPspHTTPRequest
src/duskpsp/network/networkpsp.c
+390
View File
@@ -0,0 +1,390 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#include "networkpsp.h"
#include "util/memory.h"
#include "util/string.h"
#include "assert/assert.h"
#include <psphttp.h>
#include <pspnet.h>
#include <pspnet_inet.h>
#include <pspnet_apctl.h>
static networkpsp_t NETWORK_PSP;
/* ---- HTTP thread ---- */
static int networkPspMapMethod(const networkhttprequestmethod_t method) {
switch(method) {
case NETWORK_HTTP_REQUEST_METHOD_POST: return PSP_HTTP_METHOD_POST;
case NETWORK_HTTP_REQUEST_METHOD_HEAD: return PSP_HTTP_METHOD_HEAD;
case NETWORK_HTTP_REQUEST_METHOD_GET:
default:
return PSP_HTTP_METHOD_GET;
}
}
static void networkPspHTTPThread(thread_t *thread) {
assertNotNull(thread, "Thread must not be NULL");
assertNotNull(thread->data, "Thread data must not be NULL");
networkhttppendingitem_t *item = (networkhttppendingitem_t *)thread->data;
int templateId = -1;
int connId = -1;
int reqId = -1;
templateId = sceHttpCreateTemplate(NETWORK_PSP_AGENT, PSP_HTTP_VERSION_1_1, 1);
if(templateId < 0) {
stringCopy(item->errorMessage, "sceHttpCreateTemplate failed",
NETWORK_ERROR_MESSAGE_MAX - 1);
item->isError = true;
goto done;
}
connId = sceHttpCreateConnectionWithURL(templateId, item->url, 0);
if(connId < 0) {
stringCopy(item->errorMessage, "sceHttpCreateConnectionWithURL failed",
NETWORK_ERROR_MESSAGE_MAX - 1);
item->isError = true;
goto done;
}
unsigned int contentLength = item->hasBody ? (unsigned int)strlen(item->body) : 0;
reqId = sceHttpCreateRequestWithURL(
connId, networkPspMapMethod(item->method), item->url,
(SceULong64)contentLength
);
if(reqId < 0) {
stringCopy(item->errorMessage, "sceHttpCreateRequestWithURL failed",
NETWORK_ERROR_MESSAGE_MAX - 1);
item->isError = true;
goto done;
}
for(uint32_t i = 0; i < item->headerCount; i++) {
sceHttpAddExtraHeader(reqId, item->headerKeys[i], item->headerVals[i], 0);
}
int ret;
if(item->hasBody) {
ret = sceHttpSendRequest(reqId, item->body, contentLength);
} else {
ret = sceHttpSendRequest(reqId, NULL, 0);
}
if(ret < 0) {
stringCopy(item->errorMessage, "sceHttpSendRequest failed",
NETWORK_ERROR_MESSAGE_MAX - 1);
item->isError = true;
goto done;
}
int statusCode = 0;
ret = sceHttpGetStatusCode(reqId, &statusCode);
if(ret < 0) {
stringCopy(item->errorMessage, "sceHttpGetStatusCode failed",
NETWORK_ERROR_MESSAGE_MAX - 1);
item->isError = true;
goto done;
}
item->status = (uint16_t)statusCode;
/* Read response body in chunks into the fixed buffer. */
size_t written = 0;
char_t buf[512];
while(1) {
int read = sceHttpReadData(reqId, buf, sizeof(buf));
if(read <= 0) break;
size_t space = NETWORK_HTTP_RESPONSE_MAX - 1 - written;
size_t copy = (size_t)read;
if(copy > space) copy = space;
if(copy > 0) {
memcpy(item->responseBody + written, buf, copy);
written += copy;
item->responseBody[written] = '\0';
}
if(space == 0) break;
}
item->isError = false;
done:
if(reqId >= 0) sceHttpDeleteRequest(reqId);
if(connId >= 0) sceHttpDeleteConnection(connId);
if(templateId >= 0) sceHttpDeleteTemplate(templateId);
threadMutexLock(&NETWORK_PSP.resultsMutex);
item->resultReady = true;
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
}
/* ---- Dialog state machine (pumped every frame) ---- */
static void networkPspPumpDialog() {
switch(sceUtilityNetconfGetStatus()) {
case PSP_UTILITY_DIALOG_VISIBLE:
sceUtilityNetconfUpdate(1);
break;
case PSP_UTILITY_DIALOG_QUIT:
sceUtilityNetconfShutdownStart();
break;
case PSP_UTILITY_DIALOG_FINISHED: {
int apState = 0;
sceNetApctlGetState(&apState);
if(apState == PSP_NET_APCTL_STATE_GOT_IP) {
sceUtilityLoadNetModule(PSP_NET_MODULE_HTTP);
sceUtilityLoadNetModule(PSP_NET_MODULE_SSL);
sceHttpInit(NETWORK_PSP_HTTP_HEAP_SIZE);
NETWORK_PSP.state = NETWORK_PSP_STATE_CONNECTED;
if(NETWORK_PSP.onConnected) NETWORK_PSP.onConnected(NETWORK_PSP.connectionUser);
} else {
NETWORK_PSP.state = NETWORK_PSP_STATE_FAILED;
if(NETWORK_PSP.onFailed) {
errorstate_t errState;
errState.code = ERROR_NOT_OK;
errState.message = (char_t *)"WiFi connection failed or cancelled";
errState.lines = (char_t *)"";
errorret_t err;
err.code = ERROR_NOT_OK;
err.state = &errState;
NETWORK_PSP.onFailed(err, NETWORK_PSP.connectionUser);
}
}
break;
}
default:
break;
}
}
/* ---- Public API ---- */
errorret_t networkPspInit() {
memoryZero(&NETWORK_PSP, sizeof(networkpsp_t));
threadMutexInit(&NETWORK_PSP.resultsMutex);
NETWORK_PSP.state = NETWORK_PSP_STATE_DISCONNECTED;
/* Load base net modules (FW 2.00+ style). HTTP/SSL loaded after connection. */
int ret;
ret = sceUtilityLoadNetModule(PSP_NET_MODULE_COMMON);
if(ret < 0) errorThrow("sceUtilityLoadNetModule(COMMON) failed: 0x%08X", ret);
ret = sceUtilityLoadNetModule(PSP_NET_MODULE_INET);
if(ret < 0) errorThrow("sceUtilityLoadNetModule(INET) failed: 0x%08X", ret);
/* Init the network stack. */
ret = sceNetInit(0x20000, 0x20, 0x1000, 0x20, 0x1000);
if(ret < 0) errorThrow("sceNetInit failed: 0x%08X", ret);
ret = sceNetInetInit();
if(ret < 0) errorThrow("sceNetInetInit failed: 0x%08X", ret);
ret = sceNetApctlInit(0x1800, 0x30);
if(ret < 0) errorThrow("sceNetApctlInit failed: 0x%08X", ret);
errorOk();
}
bool_t networkPspIsConnected() {
return NETWORK_PSP.state == NETWORK_PSP_STATE_CONNECTED;
}
void networkPspRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
) {
assertNotNull(onConnected, "onConnected must not be NULL");
assertNotNull(onFailed, "onFailed must not be NULL");
NETWORK_PSP.onConnected = onConnected;
NETWORK_PSP.onFailed = onFailed;
NETWORK_PSP.connectionUser = user;
NETWORK_PSP.state = NETWORK_PSP_STATE_DIALOG;
/* Configure and launch the netconf WiFi dialog.
* The dialog is pumped each frame in networkPspUpdate; it must not block. */
memoryZero(&NETWORK_PSP.dialogAdhoc, sizeof(NETWORK_PSP.dialogAdhoc));
memoryZero(&NETWORK_PSP.dialogData, sizeof(NETWORK_PSP.dialogData));
NETWORK_PSP.dialogData.base.size = sizeof(pspUtilityNetconfData);
NETWORK_PSP.dialogData.base.language = PSP_SYSTEMPARAM_LANGUAGE_ENGLISH;
NETWORK_PSP.dialogData.base.buttonSwap = PSP_UTILITY_ACCEPT_CROSS;
NETWORK_PSP.dialogData.base.graphicsThread = 17;
NETWORK_PSP.dialogData.base.accessThread = 19;
NETWORK_PSP.dialogData.base.fontThread = 18;
NETWORK_PSP.dialogData.base.soundThread = 16;
NETWORK_PSP.dialogData.action = PSP_NETCONF_ACTION_CONNECTAP;
NETWORK_PSP.dialogData.adhocparam = &NETWORK_PSP.dialogAdhoc;
int ret = sceUtilityNetconfInitStart(&NETWORK_PSP.dialogData);
if(ret < 0) {
NETWORK_PSP.state = NETWORK_PSP_STATE_FAILED;
errorstate_t errState;
errState.code = ERROR_NOT_OK;
errState.message = (char_t *)"sceUtilityNetconfInitStart failed";
errState.lines = (char_t *)"";
errorret_t err;
err.code = ERROR_NOT_OK;
err.state = &errState;
onFailed(err, user);
}
}
errorret_t networkPspUpdate() {
if(NETWORK_PSP.state == NETWORK_PSP_STATE_DIALOG) {
networkPspPumpDialog();
errorOk();
}
if(NETWORK_PSP.state == NETWORK_PSP_STATE_FAILED) {
errorOk();
}
/* Drain completed HTTP requests on the main thread. */
for(int32_t i = 0; i < NETWORK_HTTP_PENDING_MAX; i++) {
threadMutexLock(&NETWORK_PSP.resultsMutex);
networkhttppendingitem_t *item = &NETWORK_PSP.requests[i];
if(!item->used || !item->resultReady) {
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
continue;
}
bool_t isError = item->isError;
uint16_t status = item->status;
networkhttpcallback_t cb = item->callback;
networkhttperrorcallback_t errCb = item->errorCallback;
void *user = item->user;
const char_t *responseBody = item->responseBody;
const char_t *errorMessage = item->errorMessage;
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
if(isError) {
errorstate_t errState;
errState.code = ERROR_NOT_OK;
errState.message = (char_t *)errorMessage;
errState.lines = (char_t *)"";
errorret_t err;
err.code = ERROR_NOT_OK;
err.state = &errState;
errCb(err, user);
} else {
cb(status, responseBody, NULL, 0, user);
}
threadMutexLock(&NETWORK_PSP.resultsMutex);
item->used = false;
item->resultReady = false;
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
}
errorOk();
}
errorret_t networkPspDispose() {
if(NETWORK_PSP.state == NETWORK_PSP_STATE_CONNECTED) {
sceHttpEnd();
sceUtilityUnloadNetModule(PSP_NET_MODULE_SSL);
sceUtilityUnloadNetModule(PSP_NET_MODULE_HTTP);
}
sceNetApctlTerm();
sceNetInetTerm();
sceNetTerm();
sceUtilityUnloadNetModule(PSP_NET_MODULE_INET);
sceUtilityUnloadNetModule(PSP_NET_MODULE_COMMON);
threadMutexDispose(&NETWORK_PSP.resultsMutex);
errorOk();
}
void networkPspHTTPRequest(
const char_t *url,
const networkhttprequestmethod_t method,
const char_t *bodyOrNull,
const networkhttpheader_t *headers,
const uint32_t headerCount,
void *user,
networkhttpcallback_t callback,
networkhttperrorcallback_t errorCallback
) {
assertStrLenMin(url, 1, "URL must be non-empty");
assertStrLenMax(url, NETWORK_HTTP_URL_MAX, "URL exceeds maximum length");
assertNotNull(callback, "Callback must be non-NULL");
assertNotNull(errorCallback, "Error callback must be non-NULL");
assertTrue(headerCount == 0 || headers != NULL, "Headers must not be NULL when headerCount > 0");
if(NETWORK_PSP.state != NETWORK_PSP_STATE_CONNECTED) {
errorstate_t errState;
errState.code = ERROR_NOT_OK;
errState.message = (char_t *)"Network not connected";
errState.lines = (char_t *)"";
errorret_t err;
err.code = ERROR_NOT_OK;
err.state = &errState;
errorCallback(err, user);
return;
}
threadMutexLock(&NETWORK_PSP.resultsMutex);
networkhttppendingitem_t *item = NULL;
for(int32_t i = 0; i < NETWORK_HTTP_PENDING_MAX; i++) {
if(!NETWORK_PSP.requests[i].used) {
item = &NETWORK_PSP.requests[i];
break;
}
}
if(!item) {
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
errorstate_t errState;
errState.code = ERROR_NOT_OK;
errState.message = (char_t *)"No free HTTP request slots";
errState.lines = (char_t *)"";
errorret_t err;
err.code = ERROR_NOT_OK;
err.state = &errState;
errorCallback(err, user);
return;
}
memoryZero(item, sizeof(networkhttppendingitem_t));
item->used = true;
threadMutexUnlock(&NETWORK_PSP.resultsMutex);
stringCopy(item->url, url, NETWORK_HTTP_URL_MAX - 1);
item->method = method;
if(bodyOrNull != NULL) {
assertStrLenMax(bodyOrNull, NETWORK_HTTP_BODY_MAX, "Body exceeds maximum length");
stringCopy(item->body, bodyOrNull, NETWORK_HTTP_BODY_MAX - 1);
item->hasBody = true;
}
uint32_t hdrCount = headerCount;
if(hdrCount > NETWORK_HTTP_HEADER_MAX) hdrCount = NETWORK_HTTP_HEADER_MAX;
item->headerCount = hdrCount;
for(uint32_t i = 0; i < hdrCount; i++) {
assertStrLenMax(headers[i].key, NETWORK_HTTP_HEADER_KEY_MAX, "Header key exceeds maximum length");
assertStrLenMax(headers[i].value, NETWORK_HTTP_HEADER_VAL_MAX, "Header value exceeds maximum length");
stringCopy(item->headerKeys[i], headers[i].key, NETWORK_HTTP_HEADER_KEY_MAX - 1);
stringCopy(item->headerVals[i], headers[i].value, NETWORK_HTTP_HEADER_VAL_MAX - 1);
}
item->callback = callback;
item->errorCallback = errorCallback;
item->user = user;
threadInit(&item->thread, networkPspHTTPThread);
item->thread.data = item;
threadStartRequest(&item->thread);
}
src/duskpsp/network/networkpsp.h
+81
View File
@@ -0,0 +1,81 @@
/**
* Copyright (c) 2026 Dominic Masters
*
* This software is released under the MIT License.
* https://opensource.org/licenses/MIT
*/
#pragma once
#include "dusk.h"
#include "network/networkhttprequest.h"
#include "thread/thread.h"
#include <psputility.h>
#define NETWORK_HTTP_PENDING_MAX 4
#define NETWORK_HTTP_URL_MAX 512
#define NETWORK_HTTP_BODY_MAX 2048
#define NETWORK_HTTP_RESPONSE_MAX 16384
#define NETWORK_HTTP_HEADER_MAX 8
#define NETWORK_HTTP_HEADER_KEY_MAX 64
#define NETWORK_HTTP_HEADER_VAL_MAX 256
#define NETWORK_ERROR_MESSAGE_MAX 256
#define NETWORK_PSP_AGENT "DuskEngine/1.0"
#define NETWORK_PSP_HTTP_HEAP_SIZE 0x25800
typedef enum {
NETWORK_PSP_STATE_DISCONNECTED, /* Init done, no connection requested yet */
NETWORK_PSP_STATE_DIALOG, /* WiFi netconf dialog is active */
NETWORK_PSP_STATE_CONNECTED, /* AP connected, HTTP ready */
NETWORK_PSP_STATE_FAILED, /* Connection attempt failed or cancelled */
} networkpspstate_t;
typedef struct {
bool_t used;
volatile bool_t resultReady;
bool_t isError;
char_t url[NETWORK_HTTP_URL_MAX];
networkhttprequestmethod_t method;
char_t body[NETWORK_HTTP_BODY_MAX];
bool_t hasBody;
char_t headerKeys[NETWORK_HTTP_HEADER_MAX][NETWORK_HTTP_HEADER_KEY_MAX];
char_t headerVals[NETWORK_HTTP_HEADER_MAX][NETWORK_HTTP_HEADER_VAL_MAX];
uint32_t headerCount;
networkhttpcallback_t callback;
networkhttperrorcallback_t errorCallback;
void *user;
uint16_t status;
char_t responseBody[NETWORK_HTTP_RESPONSE_MAX];
char_t errorMessage[NETWORK_ERROR_MESSAGE_MAX];
thread_t thread;
} networkhttppendingitem_t;
typedef struct {
networkpspstate_t state;
pspUtilityNetconfData dialogData;
struct pspUtilityNetconfAdhoc dialogAdhoc;
void (*onConnected)(void *user);
void (*onFailed)(errorret_t error, void *user);
void *connectionUser;
networkhttppendingitem_t requests[NETWORK_HTTP_PENDING_MAX];
threadmutex_t resultsMutex;
} networkpsp_t;
errorret_t networkPspInit();
errorret_t networkPspUpdate();
errorret_t networkPspDispose();
bool_t networkPspIsConnected();
void networkPspRequestConnection(
void (*onConnected)(void *user),
void (*onFailed)(errorret_t error, void *user),
void *user
);
void networkPspHTTPRequest(
const char_t *url,
const networkhttprequestmethod_t method,
const char_t *bodyOrNull,
const networkhttpheader_t *headers,
const uint32_t headerCount,
void *user,
networkhttpcallback_t callback,
networkhttperrorcallback_t errorCallback
);