#include "stdafx.h" #include "Emu/Cell/PPUModule.h" #include "Emu/IdManager.h" #include "cellHttpUtil.h" #include "cellHttp.h" #include "cellSsl.h" LOG_CHANNEL(cellHttp); template <> void fmt_class_string::format(std::string& out, u64 arg) { format_enum(out, arg, [](auto error) { switch (error) { STR_CASE(CELL_HTTP_ERROR_ALREADY_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_NOT_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_NO_MEMORY); STR_CASE(CELL_HTTP_ERROR_NO_BUFFER); STR_CASE(CELL_HTTP_ERROR_NO_STRING); STR_CASE(CELL_HTTP_ERROR_INSUFFICIENT); STR_CASE(CELL_HTTP_ERROR_INVALID_URI); STR_CASE(CELL_HTTP_ERROR_INVALID_HEADER); STR_CASE(CELL_HTTP_ERROR_BAD_METHOD); STR_CASE(CELL_HTTP_ERROR_BAD_CLIENT); STR_CASE(CELL_HTTP_ERROR_BAD_TRANS); STR_CASE(CELL_HTTP_ERROR_NO_CONNECTION); STR_CASE(CELL_HTTP_ERROR_NO_REQUEST_SENT); STR_CASE(CELL_HTTP_ERROR_ALREADY_BUILT); STR_CASE(CELL_HTTP_ERROR_ALREADY_SENT); STR_CASE(CELL_HTTP_ERROR_NO_HEADER); STR_CASE(CELL_HTTP_ERROR_NO_CONTENT_LENGTH); STR_CASE(CELL_HTTP_ERROR_TOO_MANY_REDIRECTS); STR_CASE(CELL_HTTP_ERROR_TOO_MANY_AUTHS); STR_CASE(CELL_HTTP_ERROR_TRANS_NO_CONNECTION); STR_CASE(CELL_HTTP_ERROR_CB_FAILED); STR_CASE(CELL_HTTP_ERROR_NOT_PIPED); STR_CASE(CELL_HTTP_ERROR_OUT_OF_ORDER_PIPE); STR_CASE(CELL_HTTP_ERROR_TRANS_ABORTED); STR_CASE(CELL_HTTP_ERROR_BROKEN_PIPELINE); STR_CASE(CELL_HTTP_ERROR_UNAVAILABLE); STR_CASE(CELL_HTTP_ERROR_INVALID_VALUE); STR_CASE(CELL_HTTP_ERROR_CANNOT_AUTHENTICATE); STR_CASE(CELL_HTTP_ERROR_COOKIE_NOT_FOUND); STR_CASE(CELL_HTTP_ERROR_COOKIE_INVALID_DOMAIN); STR_CASE(CELL_HTTP_ERROR_CACHE_ALREADY_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_LINE_EXCEEDS_MAX); STR_CASE(CELL_HTTP_ERROR_REQUIRES_BASIC_AUTH); STR_CASE(CELL_HTTP_ERROR_UNKNOWN); STR_CASE(CELL_HTTP_ERROR_INTERNAL); STR_CASE(CELL_HTTP_ERROR_NONREMOVABLE); STR_CASE(CELL_HTTP_ERROR_BAD_CONN); STR_CASE(CELL_HTTP_ERROR_BAD_MAN); STR_CASE(CELL_HTTP_ERROR_NO_POOL); STR_CASE(CELL_HTTP_ERROR_NO_REQUEST); STR_CASE(CELL_HTTP_ERROR_LOCK_FAILED); STR_CASE(CELL_HTTP_ERROR_INVALID_DATA); STR_CASE(CELL_HTTP_ERROR_BROKEN_CHUNK); STR_CASE(CELL_HTTP_ERROR_DECODE_SETUP); STR_CASE(CELL_HTTP_ERROR_DECODE_STREAM); STR_CASE(CELL_HTTP_ERROR_BROKEN_DECODE_STREAM); STR_CASE(CELL_HTTP_ERROR_INVALID_DCACHE_PATH); STR_CASE(CELL_HTTP_ERROR_DCACHE_ALREADY_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_DCACHE_NOT_INITIALIZED); STR_CASE(CELL_HTTP_ERROR_TOO_MANY_DCACHE_ENTRY); STR_CASE(CELL_HTTP_ERROR_DUP_DCACHE_ENTRY); STR_CASE(CELL_HTTP_ERROR_WRITE_DCACHE); STR_CASE(CELL_HTTP_ERROR_READ_DCACHE); STR_CASE(CELL_HTTP_ERROR_CACHE_TOO_LARGE); STR_CASE(CELL_HTTP_ERROR_INVALID_DCACHE_VERSION); STR_CASE(CELL_HTTP_ERROR_DCACHE_FILE_BROKEN); STR_CASE(CELL_HTTP_ERROR_DCACHE_EXCEEDS_MAX); STR_CASE(CELL_HTTP_ERROR_DCACHE_BUSY); STR_CASE(CELL_HTTP_ERROR_DCACHE_INDEX_BROKEN); STR_CASE(CELL_HTTP_ERROR_INVALID_DCACHE_INDEX_NODE); STR_CASE(CELL_HTTP_ERROR_DCACHE_FILE_INCONSISTENCY); STR_CASE(CELL_HTTP_ERROR_DCACHE_URI_TOO_LONG); STR_CASE(CELL_HTTP_ERROR_READ_DCACHE_EOF); STR_CASE(CELL_HTTP_ERROR_END_OF_DCACHE_INDEX_NODE); STR_CASE(CELL_HTTP_ERROR_NO_CACHE_MEMORY); STR_CASE(CELL_HTTP_ERROR_DCACHE_BROKEN); STR_CASE(CELL_HTTP_ERROR_DCACHE_TOO_MANY_WRITE); STR_CASE(CELL_HTTP_ERROR_DCACHE_TOO_MANY_READ); STR_CASE(CELL_HTTP_ERROR_DCACHE_FATAL); STR_CASE(CELL_HTTP_ERROR_DCACHE_UNSUPPORTED_FEATURE); STR_CASE(CELL_HTTP_ERROR_DCACHE_INDEX_IS_ALREADY_OPEN); STR_CASE(CELL_HTTP_ERROR_DCACHE_INDEX_IS_OPENING); STR_CASE(CELL_HTTP_ERROR_DCACHE_UNKNOWN); STR_CASE(CELL_HTTP_ERROR_DCACHE_INDEX_IS_CLOSED); STR_CASE(CELL_HTTP_ERROR_DCACHE_ABORTED); STR_CASE(CELL_HTTP_ERROR_DCACHE_INDEX_IS_CLOSING); STR_CASE(CELL_HTTP_ERROR_DCACHE_UNKNOWN_INDEX_STATE); STR_CASE(CELL_HTTP_ERROR_NET_FIN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_TIMEOUT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_TIMEOUT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_TIMEOUT); } return unknown; }); } template <> void fmt_class_string::format(std::string& out, u64 arg) { format_enum(out, arg, [](auto error) { switch (error) { STR_CASE(CELL_HTTPS_ERROR_CERTIFICATE_LOAD); STR_CASE(CELL_HTTPS_ERROR_BAD_MEMORY); STR_CASE(CELL_HTTPS_ERROR_CONTEXT_CREATION); STR_CASE(CELL_HTTPS_ERROR_CONNECTION_CREATION); STR_CASE(CELL_HTTPS_ERROR_SOCKET_ASSOCIATION); STR_CASE(CELL_HTTPS_ERROR_HANDSHAKE); STR_CASE(CELL_HTTPS_ERROR_LOOKUP_CERTIFICATE); STR_CASE(CELL_HTTPS_ERROR_NO_SSL); STR_CASE(CELL_HTTPS_ERROR_KEY_LOAD); STR_CASE(CELL_HTTPS_ERROR_CERT_KEY_MISMATCH); STR_CASE(CELL_HTTPS_ERROR_KEY_NEEDS_CERT); STR_CASE(CELL_HTTPS_ERROR_CERT_NEEDS_KEY); STR_CASE(CELL_HTTPS_ERROR_RETRY_CONNECTION); STR_CASE(CELL_HTTPS_ERROR_NET_SSL_CONNECT); STR_CASE(CELL_HTTPS_ERROR_NET_SSL_SEND); STR_CASE(CELL_HTTPS_ERROR_NET_SSL_RECV); } return unknown; }); } template <> void fmt_class_string::format(std::string& out, u64 arg) { format_enum(out, arg, [](auto error) { switch (error) { STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_NETDB_INTERNAL); STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_HOST_NOT_FOUND); STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_TRY_AGAIN); STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_NO_RECOVERY); STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_NO_DATA); // STR_CASE(CELL_HTTP_ERROR_NET_RESOLVER_NO_ADDRESS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EIO); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_ABORT_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EIO); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_OPTION_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SOCKET_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EIO); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_CONNECT_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SEND_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SEND_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SEND_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SEND_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EIO); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_RECV_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_RECV_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_RECV_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_RECV_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SELECT_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_CONNECT_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_SEND_ETIME); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPERM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOENT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ESRCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EINTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENXIO); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_E2BIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOEXC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EBADF); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ECHILD); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EDEADLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOMEM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EACCES); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EFAULT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTBLK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EBUSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EEXIST); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EXDEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENODEV); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EISDIR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EINVAL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EMFILE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ETXTBSY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EFBIG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOSPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ESPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EROFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EMLINK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPIPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EDOM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ERANGE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EAGAIN); // STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EWOULDBLOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EINPROGRESS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EALREADY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTSOCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EDESTADDRREQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EMSGSIZE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROTOTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOPROTOOPT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROTONOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ESOCKTNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EOPNOTSUPP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EAFNOSUPPORT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EADDRINUSE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EADDRNOTAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENETDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENETUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENETRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ECONNABORTED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ECONNRESET); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOBUFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EISCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTCONN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ESHUTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ETOOMANYREFS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ETIMEDOUT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ECONNREFUSED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ELOOP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENAMETOOLONG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EHOSTDOWN); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EHOSTUNREACH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTEMPTY); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROCLIM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EUSERS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EDQUOT); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ESTALE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EREMOTE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EBADRPC); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ERPCMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROGUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROGMISMATCH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EPROCUNAVAIL); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOLCK); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOSYS); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EFTYPE); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENEEDAUTH); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EIDRM); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EOVERFLOW); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EILSEQ); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOTSUP); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ECANCELED); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_EBADMSG); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENODATA); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOSR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ENOSTR); STR_CASE(CELL_HTTP_ERROR_NET_SSL_RECV_ETIME); } return unknown; }); } error_code cellHttpAuthCacheExport(vm::ptr buf, u32 len, vm::ptr outsize) { cellHttp.todo("cellHttpAuthCacheExport(buf=*0x%x, len=%d, outsize=*0x%x)", buf, len, outsize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (!buf) { if (!outsize) { return CELL_HTTP_ERROR_NO_BUFFER; } } else { if (len < 9) { return CELL_HTTP_ERROR_INSUFFICIENT; } // TODO } [[maybe_unused]] u32 size = 0; // TODO if (outsize) { *outsize = 0; } return CELL_OK; } error_code cellHttpAuthCacheFlush() { cellHttp.todo("cellHttpAuthCacheFlush()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpAuthCacheGetEntryMax(u32 unk_ptr) { cellHttp.todo("cellHttpAuthCacheGetEntryMax(unk_ptr=*0x%x)", unk_ptr); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (!unk_ptr) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpAuthCacheImport(vm::ptr unk1, u32 unk2) { cellHttp.todo("cellHttpAuthCacheImport(unk1=*0x%x, unk2=0x%x)", unk1, unk2); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (!unk1 || !unk2) { return CELL_HTTP_ERROR_NO_BUFFER; } if (unk2 < 9) { return CELL_HTTP_ERROR_INSUFFICIENT; } if (unk1[0] != '\x01') { return CELL_HTTP_ERROR_INVALID_DATA; } return CELL_OK; } error_code cellHttpAuthCacheSetEntryMax(u32 unk) { cellHttp.todo("cellHttpAuthCacheSetEntryMax(unk=0x%x)", unk); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpInit(vm::ptr pool, u32 poolSize) { cellHttp.notice("cellHttpInit(pool=*0x%x, poolSize=0x%x)", pool, poolSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (man.initialized) { return CELL_HTTP_ERROR_ALREADY_INITIALIZED; } if (!pool || !poolSize) { return CELL_HTTP_ERROR_NO_BUFFER; } man.initialized = true; return CELL_OK; } error_code cellHttpEnd() { cellHttp.notice("cellHttpEnd()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } man.initialized = false; return CELL_OK; } error_code cellHttpsInit(u32 caCertNum, vm::cptr caList) { cellHttp.todo("cellHttpsInit(caCertNum=0x%x, caList=*0x%x)", caCertNum, caList); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (man.https_initialized) { return CELL_HTTP_ERROR_ALREADY_INITIALIZED; } man.https_initialized = true; return CELL_OK; } error_code cellHttpsEnd() { cellHttp.todo("cellHttpsEnd()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.https_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (!_cellSslIsInitd()) { return CELL_SSL_ERROR_NOT_INITIALIZED; } man.https_initialized = false; return CELL_OK; } error_code cellHttpSetProxy(vm::cptr proxy) { cellHttp.todo("cellHttpSetProxy(proxy=*0x%x)", proxy); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (proxy) { if (!proxy->hostname || !proxy->hostname[0]) { return CELL_HTTP_ERROR_INVALID_URI; } } return CELL_OK; } error_code cellHttpGetCookie(vm::ptr buf) { cellHttp.todo("cellHttpGetCookie(buf=*0x%x)", buf); if (!buf) { return CELL_HTTP_ERROR_NO_BUFFER; } if (false) // TODO { return CELL_HTTP_ERROR_COOKIE_NOT_FOUND; } return CELL_OK; } error_code cellHttpGetProxy(vm::ptr proxy, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpGetProxy(proxy=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", proxy, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } // if (todo) //{ // return cellHttpUtilCopyUri(proxy, some CellHttpUri, pool, poolSize, required); // } if (required) { *required = 0; } return CELL_OK; } error_code cellHttpInitCookie(vm::ptr pool, u32 poolSize) { cellHttp.todo("cellHttpInitCookie(pool=*0x%x, poolSize=0x%x)", pool, poolSize); if (!pool || !poolSize) { return CELL_HTTP_ERROR_NO_BUFFER; } auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (man.cookie_initialized) { return CELL_HTTP_ERROR_ALREADY_INITIALIZED; } man.cookie_initialized = true; return CELL_OK; } error_code cellHttpEndCookie() { cellHttp.todo("cellHttpEndCookie()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cookie_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } man.cookie_initialized = false; return CELL_OK; } error_code cellHttpAddCookieWithClientId(vm::cptr uri, vm::cptr cookie, CellHttpClientId clientId) { cellHttp.todo("cellHttpAddCookieWithClientId(uri=*0x%x, cookie=%s, clientId=0x%x)", uri, cookie, clientId); if (!uri) { return CELL_HTTP_ERROR_NO_BUFFER; } if (!cookie || !uri->hostname || !uri->path) { return CELL_HTTP_ERROR_NO_STRING; } return CELL_OK; } error_code cellHttpSessionCookieFlush(CellHttpClientId clientId) { cellHttp.todo("cellHttpSessionCookieFlush(clientId=0x%x)", clientId); return CELL_OK; } error_code cellHttpCookieExport(vm::ptr buffer, u32 size, vm::ptr exportSize) { cellHttp.todo("cellHttpCookieExport(buffer=*0x%x, size=0x%x, exportSize=*0x%x)", buffer, size, exportSize); if (buffer && size < 0x14) { return CELL_HTTP_ERROR_INSUFFICIENT; } auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cookie_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpCookieExportWithClientId(vm::ptr buffer, u32 size, vm::ptr exportSize, CellHttpClientId clientId) { cellHttp.todo("cellHttpCookieExportWithClientId(buffer=*0x%x, size=0x%x, exportSize=*0x%x, clientId=0x%x)", buffer, size, exportSize, clientId); if (buffer && size < 0x14) { return CELL_HTTP_ERROR_INSUFFICIENT; } auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cookie_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpCookieFlush() { cellHttp.todo("cellHttpCookieFlush()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cookie_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpCookieImport(vm::cptr buffer, u32 size) { cellHttp.todo("cellHttpCookieImport(buffer=*0x%x, size=0x%x)", buffer, size); if (error_code error = cellHttpCookieFlush()) { cellHttp.error("cellHttpCookieImport: cellHttpCookieFlush returned 0x%x", +error); // No return } return CELL_OK; } error_code cellHttpCookieImportWithClientId(vm::cptr buffer, u32 size, CellHttpClientId clientId) { cellHttp.todo("cellHttpCookieImportWithClientId(buffer=*0x%x, size=0x%x, clientId=0x%x)", buffer, size, clientId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cookie_initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpClientSetCookieSendCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetCookieSendCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetCookieRecvCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetCookieRecvCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpCreateClient(vm::ptr clientId) { cellHttp.todo("cellHttpCreateClient(clientId=*0x%x)", clientId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (!clientId) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpDestroyClient(CellHttpClientId clientId) { cellHttp.todo("cellHttpDestroyClient(clientId=0x%x)", clientId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetAuthenticationCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetAuthenticationCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetCacheStatus(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetCacheStatus(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetTransactionStateCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetTransactionStateCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetRedirectCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetRedirectCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetProxy(CellHttpClientId clientId, vm::cptr proxy) { cellHttp.todo("cellHttpClientSetProxy(clientId=0x%x, proxy=*0x%x)", clientId, proxy); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (proxy) { if (!proxy->hostname || !proxy->hostname[0]) { return CELL_HTTP_ERROR_INVALID_URI; } } return CELL_OK; } error_code cellHttpClientGetProxy(CellHttpClientId clientId, vm::ptr proxy, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpClientGetProxy(clientId=0x%x, proxy=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", clientId, proxy, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetVersion(CellHttpClientId clientId, u32 major, u32 minor) { cellHttp.todo("cellHttpClientSetPipeline(clientId=0x%x, major=0x%x, minor=0x%x)", clientId, major, minor); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetVersion(CellHttpClientId clientId, vm::ptr major, vm::ptr minor) { cellHttp.todo("cellHttpClientGetVersion(clientId=0x%x, major=*0x%x, minor=*0x%x)", clientId, major, minor); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!major || !minor) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetPipeline(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetPipeline(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetPipeline(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetPipeline(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetKeepAlive(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetKeepAlive(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetKeepAlive(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetKeepAlive(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetAutoRedirect(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetAutoRedirect(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetAutoRedirect(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetAutoRedirect(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetAutoAuthentication(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetAutoAuthentication(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetAutoAuthentication(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetAutoAuthentication(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetAuthenticationCacheStatus(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetAuthenticationCacheStatus(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetAuthenticationCacheStatus(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetAuthenticationCacheStatus(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetCookieStatus(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetCookieStatus(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetCookieStatus(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetCookieStatus(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetUserAgent(CellHttpClientId clientId, vm::cptr userAgent) { cellHttp.todo("cellHttpClientSetUserAgent(clientId=0x%x, userAgent=%s)", clientId, userAgent); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!userAgent) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientGetUserAgent(CellHttpClientId clientId, vm::ptr userAgent, u32 size, vm::ptr required) { cellHttp.todo("cellHttpClientGetUserAgent(clientId=0x%x, userAgent=*0x%x, size=%d, required=*0x%x)", clientId, size, userAgent, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!userAgent || !size) { if (!required) { return CELL_HTTP_ERROR_NO_BUFFER; } } return CELL_OK; } error_code cellHttpClientSetResponseBufferMax(CellHttpClientId clientId, u32 max) { cellHttp.todo("cellHttpClientSetResponseBufferMax(clientId=0x%x, max=%d)", clientId, max); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (max < 1500) { max = 1500; } return CELL_OK; } error_code cellHttpClientGetResponseBufferMax(CellHttpClientId clientId, vm::ptr max) { cellHttp.todo("cellHttpClientGetResponseBufferMax(clientId=0x%x, max=*0x%x)", clientId, max); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!max) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientCloseAllConnections(CellHttpClientId clientId) { cellHttp.todo("cellHttpClientCloseAllConnections(clientId=0x%x)", clientId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientCloseConnections(CellHttpClientId clientId, vm::cptr uri) { cellHttp.todo("cellHttpClientCloseConnections(clientId=0x%x, uri=*0x%x)", clientId, uri); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientPollConnections(CellHttpClientId clientId, vm::ptr transId, s64 usec) { cellHttp.todo("cellHttpClientPollConnections(clientId=0x%x, transId=*0x%x, usec=%d)", clientId, transId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetConnectionStateCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetConnectionStateCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetConnectionWaitStatus(CellHttpClientId clientId, b8 enable) { cellHttp.todo("cellHttpClientSetConnectionWaitStatus(clientId=0x%x, enable=%d)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetConnectionWaitStatus(CellHttpClientId clientId, vm::ptr enable) { cellHttp.todo("cellHttpClientGetConnectionWaitStatus(clientId=0x%x, enable=*0x%x)", clientId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetConnectionWaitTimeout(CellHttpClientId clientId, s64 usec) { cellHttp.todo("cellHttpClientSetConnectionWaitTimeout(clientId=0x%x, usec=%d)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetConnectionWaitTimeout(CellHttpClientId clientId, vm::ptr usec) { cellHttp.todo("cellHttpClientGetConnectionWaitTimeout(clientId=0x%x, usec=*0x%x)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!usec) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetRecvTimeout(CellHttpClientId clientId, s64 usec) { cellHttp.todo("cellHttpClientSetRecvTimeout(clientId=0x%x, usec=%d)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetRecvTimeout(CellHttpClientId clientId, vm::ptr usec) { cellHttp.todo("cellHttpClientGetRecvTimeout(clientId=0x%x, usec=*0x%x)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!usec) // TODO { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetSendTimeout(CellHttpClientId clientId, s64 usec) { cellHttp.todo("cellHttpClientSetSendTimeout(clientId=0x%x, usec=%d)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetSendTimeout(CellHttpClientId clientId, vm::ptr usec) { cellHttp.todo("cellHttpClientGetSendTimeout(clientId=0x%x, usec=*0x%x)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!usec) // TODO { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetConnTimeout(CellHttpClientId clientId, s64 usec) { cellHttp.todo("cellHttpClientSetConnTimeout(clientId=0x%x, usec=%d)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetConnTimeout(CellHttpClientId clientId, vm::ptr usec) { cellHttp.todo("cellHttpClientGetConnTimeout(clientId=0x%x, usec=*0x%x)", clientId, usec); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!usec) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetTotalPoolSize(CellHttpClientId clientId, u32 poolSize) { cellHttp.todo("cellHttpClientSetTotalPoolSize(clientId=0x%x, poolSize=%d)", clientId, poolSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetTotalPoolSize(CellHttpClientId clientId, vm::ptr poolSize) { cellHttp.todo("cellHttpClientGetTotalPoolSize(clientId=0x%x, poolSize=*0x%x)", clientId, poolSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!poolSize) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetPerHostPoolSize(CellHttpClientId clientId, u32 poolSize) { cellHttp.todo("cellHttpClientSetPerHostPoolSize(clientId=0x%x, poolSize=%d)", clientId, poolSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetPerHostPoolSize(CellHttpClientId clientId, vm::ptr poolSize) { cellHttp.todo("cellHttpClientGetPerHostPoolSize(clientId=0x%x, poolSize=*0x%x)", clientId, poolSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!poolSize) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetPerHostKeepAliveMax(CellHttpClientId clientId, u32 maxSize) { cellHttp.todo("cellHttpClientSetPerHostKeepAliveMax(clientId=0x%x, maxSize=%d)", clientId, maxSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetPerHostKeepAliveMax(CellHttpClientId clientId, vm::ptr maxSize) { cellHttp.todo("cellHttpClientGetPerHostKeepAliveMax(clientId=0x%x, maxSize=*0x%x)", clientId, maxSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!maxSize) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetPerPipelineMax(CellHttpClientId clientId, u32 pipeMax) { cellHttp.todo("cellHttpClientSetPerPipelineMax(clientId=0x%x, pipeMax=%d)", clientId, pipeMax); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetPerPipelineMax(CellHttpClientId clientId, vm::ptr pipeMax) { cellHttp.todo("cellHttpClientGetPerPipelineMax(clientId=0x%x, pipeMax=*0x%x)", clientId, pipeMax); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!pipeMax) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetRecvBufferSize(CellHttpClientId clientId, s32 size) { cellHttp.todo("cellHttpClientSetRecvBufferSize(clientId=0x%x, size=%d)", clientId, size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetRecvBufferSize(CellHttpClientId clientId, vm::ptr size) { cellHttp.todo("cellHttpClientGetRecvBufferSize(clientId=0x%x, size=*0x%x)", clientId, size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!size) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetSendBufferSize(CellHttpClientId clientId, s32 size) { cellHttp.todo("cellHttpClientSetSendBufferSize(clientId=0x%x, size=%d)", clientId, size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetSendBufferSize(CellHttpClientId clientId, vm::ptr size) { cellHttp.todo("cellHttpClientGetSendBufferSize(clientId=0x%x, size=*0x%x)", clientId, size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!size) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientGetAllHeaders(CellHttpClientId clientId, vm::pptr headers, vm::ptr items, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpClientGetAllHeaders(clientId=0x%x, headers=*0x%x, items=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", clientId, headers, items, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if ((!pool || !headers) && !required) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetHeader(CellHttpClientId clientId, vm::cptr header) { cellHttp.todo("cellHttpClientSetHeader(clientId=0x%x, header=*0x%x)", clientId, header); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!header) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientGetHeader(CellHttpClientId clientId, vm::ptr header, vm::cptr name, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpClientGetHeader(clientId=0x%x, header=*0x%x, name=%s, pool=*0x%x, poolSize=0x%x, required=*0x%x)", clientId, header, name, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!name) { return CELL_HTTP_ERROR_NO_STRING; } return CELL_OK; } error_code cellHttpClientAddHeader(CellHttpClientId clientId, vm::cptr header) { cellHttp.todo("cellHttpClientAddHeader(clientId=0x%x, header=*0x%x)", clientId, header); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientDeleteHeader(CellHttpClientId clientId, vm::cptr name) { cellHttp.todo("cellHttpClientDeleteHeader(clientId=0x%x, name=%s)", clientId, name); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetSslCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetSslCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientSetSslClientCertificate(CellHttpClientId clientId, vm::cptr cert, vm::cptr privKey) { cellHttp.todo("cellHttpClientSetSslClientCertificate(clientId=0x%x, cert=*0x%x, privKey=*0x%x)", clientId, cert, privKey); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!cert && privKey) { return CELL_HTTPS_ERROR_KEY_NEEDS_CERT; } if (cert && !privKey) { return CELL_HTTPS_ERROR_CERT_NEEDS_KEY; } return CELL_OK; } error_code cellHttpCreateTransaction(vm::ptr transId, CellHttpClientId clientId, vm::cptr method, vm::cptr uri) { cellHttp.todo("cellHttpCreateTransaction(transId=*0x%x, clientId=0x%x, method=%s, uri=*0x%x)", transId, clientId, method, uri); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } // if (error_code error = syscall_sys_memory_get_page_attribute(clientId)) //{ // return error; // } if (!uri || !uri->hostname || !uri->hostname[0]) { return CELL_HTTP_ERROR_INVALID_URI; } return CELL_OK; } error_code cellHttpDestroyTransaction(CellHttpTransId transId) { cellHttp.todo("cellHttpDestroyTransaction(transId=0x%x)", transId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetUri(CellHttpTransId transId, vm::ptr uri, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpTransactionGetUri(transId=0x%x, uri=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, uri, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionSetUri(CellHttpTransId transId, vm::cptr uri) // TODO: more params? { cellHttp.todo("cellHttpTransactionSetUri(transId=0x%x, uri=*0x%x)", transId, uri); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!uri || !uri->hostname || !uri->hostname[0]) { return CELL_HTTP_ERROR_INVALID_URI; } if (uri->scheme && false) // TODO { return CELL_HTTP_ERROR_INVALID_URI; } return CELL_OK; } error_code cellHttpTransactionCloseConnection(CellHttpTransId transId) { cellHttp.todo("cellHttpTransactionCloseConnection(transId=0x%x)", transId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionReleaseConnection(CellHttpTransId transId, vm::ptr sid) { cellHttp.todo("cellHttpTransactionReleaseConnection(transId=0x%x, sid=*0x%x)", transId, sid); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!sid) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpTransactionAbortConnection(CellHttpTransId transId) { cellHttp.todo("cellHttpTransactionAbortConnection(transId=0x%x)", transId); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpSendRequest(CellHttpTransId transId, vm::cptr buf, u32 size, vm::ptr sent) { cellHttp.todo("cellHttpSendRequest(transId=0x%x, buf=*0x%x, size=0x%x, sent=*0x%x)", transId, buf, size, sent); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpRequestSetContentLength(CellHttpTransId transId, u64 totalSize) { cellHttp.todo("cellHttpRequestSetContentLength(transId=0x%x, totalSize=0x%x)", transId, totalSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpRequestGetContentLength(CellHttpTransId transId, vm::ptr totalSize) { cellHttp.todo("cellHttpRequestGetContentLength(transId=0x%x, totalSize=*0x%x)", transId, totalSize); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!totalSize) { return CELL_HTTP_ERROR_NO_BUFFER; } if (false) // TODO { return CELL_HTTP_ERROR_NO_CONTENT_LENGTH; } return CELL_OK; } error_code cellHttpRequestSetChunkedTransferStatus(CellHttpTransId transId, b8 enable) { cellHttp.todo("cellHttpRequestSetChunkedTransferStatus(transId=0x%x, enable=%d)", transId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpRequestGetChunkedTransferStatus(CellHttpTransId transId, vm::ptr enable) { cellHttp.todo("cellHttpRequestGetChunkedTransferStatus(transId=0x%x, enable=*0x%x)", transId, enable); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!enable) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpRequestGetAllHeaders(CellHttpTransId transId, vm::pptr headers, vm::ptr items, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpRequestGetAllHeaders(transId=0x%x, headers=*0x%x, items=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, headers, items, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!required && (!pool || !headers)) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpRequestSetHeader(CellHttpTransId transId, vm::cptr header) { cellHttp.todo("cellHttpRequestSetHeader(transId=0x%x, header=*0x%x)", transId, header); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!header) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpRequestGetHeader(CellHttpTransId transId, vm::ptr header, vm::cptr name, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpRequestGetHeader(transId=0x%x, header=*0x%x, name=%s, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, header, name, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!name) { return CELL_HTTP_ERROR_NO_STRING; } return CELL_OK; } error_code cellHttpRequestAddHeader(CellHttpTransId transId, vm::cptr header) { cellHttp.todo("cellHttpRequestAddHeader(transId=0x%x, header=*0x%x)", transId, header); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!header) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpRequestDeleteHeader(CellHttpTransId transId, vm::cptr name) { cellHttp.todo("cellHttpRequestDeleteHeader(transId=0x%x, name=%s)", transId, name); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!name) { return CELL_HTTP_ERROR_NO_STRING; } return CELL_OK; } error_code cellHttpRecvResponse(CellHttpTransId transId, vm::ptr buf, u32 size, vm::ptr recvd) { cellHttp.todo("cellHttpRecvResponse(transId=0x%x, buf=*0x%x, size=0x%x, recvd=*0x%x)", transId, buf, size, recvd); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpResponseGetAllHeaders(CellHttpTransId transId, vm::pptr headers, vm::ptr items, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpResponseGetAllHeaders(transId=0x%x, headers=*0x%x, items=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, headers, items, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!required && (!pool || !headers)) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpResponseGetHeader(CellHttpTransId transId, vm::ptr header, vm::cptr name, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpResponseGetHeader(transId=0x%x, header=*0x%x, name=%s, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, header, name, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!name) { return CELL_HTTP_ERROR_NO_STRING; } return CELL_OK; } error_code cellHttpResponseGetContentLength(CellHttpTransId transId, vm::ptr length) { cellHttp.todo("cellHttpResponseGetContentLength(transId=0x%x, length=*0x%x)", transId, length); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!length) { return CELL_HTTP_ERROR_NO_BUFFER; } if (false) // TODO { return CELL_HTTP_ERROR_NO_CONTENT_LENGTH; } return CELL_OK; } error_code cellHttpResponseGetStatusCode(CellHttpTransId transId, vm::ptr code) { cellHttp.todo("cellHttpResponseGetStatusCode(transId=0x%x, code=*0x%x)", transId, code); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } if (!code) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpResponseGetStatusLine(CellHttpTransId transId, vm::ptr status, vm::ptr pool, u32 poolSize, vm::ptr required) { cellHttp.todo("cellHttpResponseGetStatusLine(transId=0x%x, status=*0x%x, pool=*0x%x, poolSize=0x%x, required=*0x%x)", transId, status, pool, poolSize, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslCipherName(CellHttpTransId transId, vm::ptr name, u32 size, vm::ptr required) { cellHttp.todo("cellHttpTransactionGetSslCipherName(transId=0x%x, name=*0x%x, size=0x%x, required=*0x%x)", transId, name, size, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslCipherId(CellHttpTransId transId, vm::ptr id) { cellHttp.todo("cellHttpTransactionGetSslCipherId(transId=0x%x, id=*0x%x)", transId, id); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslCipherVersion(CellHttpTransId transId, vm::ptr version, u32 size, vm::ptr required) { cellHttp.todo("cellHttpTransactionGetSslCipherVersion(transId=0x%x, version=*0x%x, size=0x%x, required=*0x%x)", transId, version, size, required); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslCipherBits(CellHttpTransId transId, vm::ptr effectiveBits, vm::ptr algorithmBits) { cellHttp.todo("cellHttpTransactionGetSslCipherBits(transId=0x%x, effectiveBits=*0x%x, effectiveBits=*0x%x)", transId, effectiveBits, algorithmBits); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslCipherString(CellHttpTransId transId, vm::ptr buffer, u32 size) { cellHttp.todo("cellHttpTransactionGetSslCipherString(transId=0x%x, buffer=*0x%x, size=0x%x)", transId, buffer, size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslVersion(CellHttpTransId transId, vm::ptr version) { cellHttp.todo("cellHttpTransactionGetSslVersion(transId=0x%x, version=*0x%x)", transId, version); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpTransactionGetSslId(CellHttpTransId transId, vm::pptr id) { cellHttp.todo("cellHttpTransactionGetSslId(transId=0x%x, id=*0x%x)", transId, id); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_TRANS; } return CELL_OK; } error_code cellHttpClientSetSslVersion(CellHttpClientId clientId, s32 version) { cellHttp.todo("cellHttpClientSetSslVersion(clientId=0x%x, version=%d)", clientId, version); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpClientGetSslVersion(CellHttpClientId clientId, vm::ptr version) { cellHttp.todo("cellHttpClientGetSslVersion(clientId=0x%x, version=*0x%x)", clientId, version); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } if (!version) { return CELL_HTTP_ERROR_NO_BUFFER; } return CELL_OK; } error_code cellHttpClientSetMinSslVersion(CellHttpClientId clientId, s32 version) { cellHttp.todo("cellHttpClientSetMinSslVersion(clientId=0x%x, version=%d)", clientId, version); if (version != CELL_SSL_VERSION_TLS1) { if (version != CELL_SSL_VERSION_SSL3) { return CELL_HTTP_ERROR_INVALID_VALUE; } version = 2; // TODO: this can't be right, can it ? } return cellHttpClientSetSslVersion(clientId, version); } error_code cellHttpClientGetMinSslVersion(CellHttpClientId clientId, vm::ptr version) { cellHttp.todo("cellHttpClientGetMinSslVersion(clientId=0x%x, version=*0x%x)", clientId, version); if (error_code error = cellHttpClientGetSslVersion(clientId, version)) { return error; } if (*version == 2) { *version = CELL_SSL_VERSION_SSL3; } return CELL_OK; } error_code cellHttpClientSetSslIdDestroyCallback(CellHttpClientId clientId, vm::ptr cbfunc, vm::ptr userArg) { cellHttp.todo("cellHttpClientSetSslIdDestroyCallback(clientId=0x%x, cbfunc=*0x%x, userArg=*0x%x)", clientId, cbfunc, userArg); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.initialized) { return CELL_HTTP_ERROR_NOT_INITIALIZED; } if (false) // TODO { return CELL_HTTP_ERROR_BAD_CLIENT; } return CELL_OK; } error_code cellHttpFlushCache() { cellHttp.todo("cellHttpFlushCache()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cache_initialized) { return CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpEndCache() { cellHttp.todo("cellHttpEndCache()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cache_initialized) { return CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED; } man.cache_initialized = false; return CELL_OK; } error_code cellHttpInitCache(u32 unk) { cellHttp.todo("cellHttpInitCache(unk=0x%x)", unk); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (man.cache_initialized) { return CELL_HTTP_ERROR_CACHE_ALREADY_INITIALIZED; } man.cache_initialized = true; return CELL_OK; } error_code cellHttpEndExternalCache() { cellHttp.todo("cellHttpEndExternalCache()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.ext_cache_initialized) { return CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED; } man.ext_cache_initialized = false; return CELL_OK; } error_code cellHttpInitExternalCache(vm::ptr buf, u32 size) { cellHttp.todo("cellHttpInitExternalCache(buf=*0x%x, size=0x%x)", size); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (man.ext_cache_initialized) { return CELL_HTTP_ERROR_CACHE_ALREADY_INITIALIZED; } if (buf) { std::memset(buf.get_ptr(), 0, size); } if (size >= 512) { // TODO } man.ext_cache_initialized = true; return CELL_OK; } error_code cellHttpFlushExternalCache() { cellHttp.todo("cellHttpFlushExternalCache()"); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.ext_cache_initialized) { return CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpGetCacheInfo(vm::ptr buf) { cellHttp.todo("cellHttpGetCacheInfo(buf=*0x%x)", buf); auto& man = g_fxo->get(); std::lock_guard lock(man.mtx); if (!man.cache_initialized) { return CELL_HTTP_ERROR_CACHE_NOT_INITIALIZED; } return CELL_OK; } error_code cellHttpGetMemoryInfo(vm::ptr heapSize, vm::ptr param_2, vm::ptr param_3) { cellHttp.todo("cellHttpGetMemoryInfo(heapSize=*0x%x, param_2=*0x%x, param_3=*0x%x)", heapSize, param_2, param_3); if (heapSize) { //*heapSize = _sys_heap_get_total_free_size(); } if (!param_2 && !param_3) { return CELL_OK; } if (param_2) { *param_2 = *param_3; } //*param_3 = _sys_heap_get_mallinfo(); return CELL_OK; } DECLARE(ppu_module_manager::cellHttp)("cellHttp", []() { REG_FUNC(cellHttp, cellHttpAuthCacheExport); REG_FUNC(cellHttp, cellHttpAuthCacheFlush); REG_FUNC(cellHttp, cellHttpAuthCacheGetEntryMax); REG_FUNC(cellHttp, cellHttpAuthCacheImport); REG_FUNC(cellHttp, cellHttpAuthCacheSetEntryMax); REG_FUNC(cellHttp, cellHttpInit); REG_FUNC(cellHttp, cellHttpEnd); REG_FUNC(cellHttp, cellHttpsInit); REG_FUNC(cellHttp, cellHttpsEnd); REG_FUNC(cellHttp, cellHttpSetProxy); REG_FUNC(cellHttp, cellHttpGetCookie); REG_FUNC(cellHttp, cellHttpGetProxy); REG_FUNC(cellHttp, cellHttpInitCookie); REG_FUNC(cellHttp, cellHttpEndCookie); REG_FUNC(cellHttp, cellHttpAddCookieWithClientId); REG_FUNC(cellHttp, cellHttpSessionCookieFlush); REG_FUNC(cellHttp, cellHttpCookieExport); REG_FUNC(cellHttp, cellHttpCookieExportWithClientId); REG_FUNC(cellHttp, cellHttpCookieFlush); REG_FUNC(cellHttp, cellHttpCookieImport); REG_FUNC(cellHttp, cellHttpCookieImportWithClientId); REG_FUNC(cellHttp, cellHttpClientSetCookieSendCallback); REG_FUNC(cellHttp, cellHttpClientSetCookieRecvCallback); REG_FUNC(cellHttp, cellHttpCreateClient); REG_FUNC(cellHttp, cellHttpDestroyClient); REG_FUNC(cellHttp, cellHttpClientSetAuthenticationCallback); REG_FUNC(cellHttp, cellHttpClientSetTransactionStateCallback); REG_FUNC(cellHttp, cellHttpClientSetRedirectCallback); REG_FUNC(cellHttp, cellHttpClientSetCacheStatus); REG_FUNC(cellHttp, cellHttpClientSetProxy); REG_FUNC(cellHttp, cellHttpClientGetProxy); REG_FUNC(cellHttp, cellHttpClientSetVersion); REG_FUNC(cellHttp, cellHttpClientGetVersion); REG_FUNC(cellHttp, cellHttpClientSetPipeline); REG_FUNC(cellHttp, cellHttpClientGetPipeline); REG_FUNC(cellHttp, cellHttpClientSetKeepAlive); REG_FUNC(cellHttp, cellHttpClientGetKeepAlive); REG_FUNC(cellHttp, cellHttpClientSetAutoRedirect); REG_FUNC(cellHttp, cellHttpClientGetAutoRedirect); REG_FUNC(cellHttp, cellHttpClientSetAutoAuthentication); REG_FUNC(cellHttp, cellHttpClientGetAutoAuthentication); REG_FUNC(cellHttp, cellHttpClientSetAuthenticationCacheStatus); REG_FUNC(cellHttp, cellHttpClientGetAuthenticationCacheStatus); REG_FUNC(cellHttp, cellHttpClientSetCookieStatus); REG_FUNC(cellHttp, cellHttpClientGetCookieStatus); REG_FUNC(cellHttp, cellHttpClientSetUserAgent); REG_FUNC(cellHttp, cellHttpClientGetUserAgent); REG_FUNC(cellHttp, cellHttpClientSetResponseBufferMax); REG_FUNC(cellHttp, cellHttpClientGetResponseBufferMax); REG_FUNC(cellHttp, cellHttpClientCloseAllConnections); REG_FUNC(cellHttp, cellHttpClientCloseConnections); REG_FUNC(cellHttp, cellHttpClientPollConnections); REG_FUNC(cellHttp, cellHttpClientSetConnectionStateCallback); REG_FUNC(cellHttp, cellHttpClientGetConnectionWaitStatus); REG_FUNC(cellHttp, cellHttpClientSetConnectionWaitStatus); REG_FUNC(cellHttp, cellHttpClientGetConnectionWaitTimeout); REG_FUNC(cellHttp, cellHttpClientSetConnectionWaitTimeout); REG_FUNC(cellHttp, cellHttpClientSetRecvTimeout); REG_FUNC(cellHttp, cellHttpClientGetRecvTimeout); REG_FUNC(cellHttp, cellHttpClientSetSendTimeout); REG_FUNC(cellHttp, cellHttpClientGetSendTimeout); REG_FUNC(cellHttp, cellHttpClientSetConnTimeout); REG_FUNC(cellHttp, cellHttpClientGetConnTimeout); REG_FUNC(cellHttp, cellHttpClientSetTotalPoolSize); REG_FUNC(cellHttp, cellHttpClientGetTotalPoolSize); REG_FUNC(cellHttp, cellHttpClientSetPerHostPoolSize); REG_FUNC(cellHttp, cellHttpClientGetPerHostPoolSize); REG_FUNC(cellHttp, cellHttpClientSetPerHostKeepAliveMax); REG_FUNC(cellHttp, cellHttpClientGetPerHostKeepAliveMax); REG_FUNC(cellHttp, cellHttpClientSetPerPipelineMax); REG_FUNC(cellHttp, cellHttpClientGetPerPipelineMax); REG_FUNC(cellHttp, cellHttpClientSetRecvBufferSize); REG_FUNC(cellHttp, cellHttpClientGetRecvBufferSize); REG_FUNC(cellHttp, cellHttpClientSetSendBufferSize); REG_FUNC(cellHttp, cellHttpClientGetSendBufferSize); REG_FUNC(cellHttp, cellHttpClientGetAllHeaders); REG_FUNC(cellHttp, cellHttpClientSetHeader); REG_FUNC(cellHttp, cellHttpClientGetHeader); REG_FUNC(cellHttp, cellHttpClientAddHeader); REG_FUNC(cellHttp, cellHttpClientDeleteHeader); REG_FUNC(cellHttp, cellHttpClientSetSslCallback); REG_FUNC(cellHttp, cellHttpClientSetSslClientCertificate); REG_FUNC(cellHttp, cellHttpCreateTransaction); REG_FUNC(cellHttp, cellHttpDestroyTransaction); REG_FUNC(cellHttp, cellHttpTransactionGetUri); REG_FUNC(cellHttp, cellHttpTransactionSetUri); REG_FUNC(cellHttp, cellHttpTransactionCloseConnection); REG_FUNC(cellHttp, cellHttpTransactionReleaseConnection); REG_FUNC(cellHttp, cellHttpTransactionAbortConnection); REG_FUNC(cellHttp, cellHttpSendRequest); REG_FUNC(cellHttp, cellHttpRequestSetContentLength); REG_FUNC(cellHttp, cellHttpRequestGetContentLength); REG_FUNC(cellHttp, cellHttpRequestSetChunkedTransferStatus); REG_FUNC(cellHttp, cellHttpRequestGetChunkedTransferStatus); REG_FUNC(cellHttp, cellHttpRequestGetAllHeaders); REG_FUNC(cellHttp, cellHttpRequestSetHeader); REG_FUNC(cellHttp, cellHttpRequestGetHeader); REG_FUNC(cellHttp, cellHttpRequestAddHeader); REG_FUNC(cellHttp, cellHttpRequestDeleteHeader); REG_FUNC(cellHttp, cellHttpRecvResponse); REG_FUNC(cellHttp, cellHttpResponseGetAllHeaders); REG_FUNC(cellHttp, cellHttpResponseGetHeader); REG_FUNC(cellHttp, cellHttpResponseGetContentLength); REG_FUNC(cellHttp, cellHttpResponseGetStatusCode); REG_FUNC(cellHttp, cellHttpResponseGetStatusLine); REG_FUNC(cellHttp, cellHttpTransactionGetSslCipherName); REG_FUNC(cellHttp, cellHttpTransactionGetSslCipherId); REG_FUNC(cellHttp, cellHttpTransactionGetSslCipherVersion); REG_FUNC(cellHttp, cellHttpTransactionGetSslCipherBits); REG_FUNC(cellHttp, cellHttpTransactionGetSslCipherString); REG_FUNC(cellHttp, cellHttpTransactionGetSslVersion); REG_FUNC(cellHttp, cellHttpTransactionGetSslId); REG_FUNC(cellHttp, cellHttpClientSetMinSslVersion); REG_FUNC(cellHttp, cellHttpClientGetMinSslVersion); REG_FUNC(cellHttp, cellHttpClientSetSslVersion); REG_FUNC(cellHttp, cellHttpClientGetSslVersion); REG_FUNC(cellHttp, cellHttpClientSetSslIdDestroyCallback); REG_FUNC(cellHttp, cellHttpFlushCache); REG_FUNC(cellHttp, cellHttpEndCache); REG_FUNC(cellHttp, cellHttpEndExternalCache); REG_FUNC(cellHttp, cellHttpInitCache); REG_FUNC(cellHttp, cellHttpGetCacheInfo); REG_FUNC(cellHttp, cellHttpGetMemoryInfo); }); DECLARE(ppu_module_manager::cellHttps)("cellHttps", []() { // cellHttps doesn't have functions (cellHttpsInit belongs to cellHttp, for example) });