ocrm.bsky.social
the game where you go into mines and start crafting! but for consoles (forked directly from smartcmd's github)
1#include "stdafx.h"
2#include <sce_atomic.h>
3#include <fios2.h>
4#include <libsysmodule.h>
5#include <perf.h>
6#include <audioout.h>
7#include <game_custom_data_dialog.h>
8#include <system_service.h>
9#include <error_dialog.h>
10#include <message_dialog.h>
11
12
13//#include <app_content.h>
14
15// These are required so that the heap will automatically expand - default is limited to 256KB
16size_t sceLibcHeapSize = SCE_LIBC_HEAP_SIZE_EXTENDED_ALLOC_NO_LIMIT;
17unsigned int sceLibcHeapExtendedAlloc = 1;
18
19//static char dirName[128];
20//static char contentInfoPath[128];
21static char usrdirPath[128];
22int32_t hBGMAudio;
23
24//static char sc_loadPath[] = {"/app0/"};
25//const char* getConsoleHomePath() { return sc_loadPath; }
26
27char* getUsrDirPath()
28{
29 return usrdirPath;
30}
31
32
33int _wcsicmp( const wchar_t * dst, const wchar_t * src )
34{
35 wchar_t f,l;
36
37 // validation section
38 // _VALIDATE_RETURN(dst != NULL, EINVAL, _NLSCMPERROR);
39 // _VALIDATE_RETURN(src != NULL, EINVAL, _NLSCMPERROR);
40
41 do {
42 f = towlower(*dst);
43 l = towlower(*src);
44 dst++;
45 src++;
46 } while ( (f) && (f == l) );
47 return (int)(f - l);
48}
49
50size_t wcsnlen(const wchar_t *wcs, size_t maxsize)
51{
52 size_t n;
53
54// Note that we do not check if s == NULL, because we do not
55// return errno_t...
56
57 for (n = 0; n < maxsize && *wcs; n++, wcs++)
58 ;
59
60 return n;
61}
62
63
64VOID GetSystemTime( LPSYSTEMTIME lpSystemTime)
65{
66 SceRtcDateTime dateTime;
67 int err = sceRtcGetCurrentClock(&dateTime, 0);
68 assert(err == SCE_OK);
69
70 lpSystemTime->wYear = sceRtcGetYear(&dateTime);
71 lpSystemTime->wMonth = sceRtcGetMonth(&dateTime);
72 lpSystemTime->wDay = sceRtcGetDay(&dateTime);
73 lpSystemTime->wDayOfWeek = sceRtcGetDayOfWeek(lpSystemTime->wYear, lpSystemTime->wMonth, lpSystemTime->wDay);
74 lpSystemTime->wHour = sceRtcGetHour(&dateTime);
75 lpSystemTime->wMinute = sceRtcGetMinute(&dateTime);
76 lpSystemTime->wSecond = sceRtcGetSecond(&dateTime);
77 lpSystemTime->wMilliseconds = sceRtcGetMicrosecond(&dateTime)/1000;
78}
79BOOL FileTimeToSystemTime(CONST FILETIME *lpFileTime, LPSYSTEMTIME lpSystemTime) { ORBIS_STUBBED; return false; }
80BOOL SystemTimeToFileTime(CONST SYSTEMTIME *lpSystemTime, LPFILETIME lpFileTime) { ORBIS_STUBBED; return false; }
81VOID GetLocalTime(LPSYSTEMTIME lpSystemTime)
82{
83 SceRtcDateTime dateTime;
84 int err = sceRtcGetCurrentClockLocalTime(&dateTime);
85 assert(err == SCE_OK );
86
87 lpSystemTime->wYear = sceRtcGetYear(&dateTime);
88 lpSystemTime->wMonth = sceRtcGetMonth(&dateTime);
89 lpSystemTime->wDay = sceRtcGetDay(&dateTime);
90 lpSystemTime->wDayOfWeek = sceRtcGetDayOfWeek(lpSystemTime->wYear, lpSystemTime->wMonth, lpSystemTime->wDay);
91 lpSystemTime->wHour = sceRtcGetHour(&dateTime);
92 lpSystemTime->wMinute = sceRtcGetMinute(&dateTime);
93 lpSystemTime->wSecond = sceRtcGetSecond(&dateTime);
94 lpSystemTime->wMilliseconds = sceRtcGetMicrosecond(&dateTime)/1000;
95}
96
97HANDLE CreateEvent(void* lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName) { ORBIS_STUBBED; return NULL; }
98VOID Sleep(DWORD dwMilliseconds)
99{
100 C4JThread::Sleep(dwMilliseconds);
101}
102
103BOOL SetThreadPriority(HANDLE hThread, int nPriority) { ORBIS_STUBBED; return FALSE; }
104DWORD WaitForSingleObject(HANDLE hHandle, DWORD dwMilliseconds) { ORBIS_STUBBED; return false; }
105
106LONG InterlockedCompareExchangeRelease(LONG volatile *Destination, LONG Exchange,LONG Comperand )
107{
108 return sceAtomicCompareAndSwap32((int32_t*)Destination, (int32_t)Comperand, (int32_t)Exchange);
109}
110
111LONG64 InterlockedCompareExchangeRelease64(LONG64 volatile *Destination, LONG64 Exchange, LONG64 Comperand)
112{
113 return sceAtomicCompareAndSwap64((int64_t*)Destination, (int64_t)Comperand, (int64_t)Exchange);
114}
115
116
117ScePthreadMutexattr mutexParams;
118int64_t g_OpStorage[4*1024]; /* 32KiB */
119int64_t g_ChunkStorage[8*1024]; /* 64KiB */
120int64_t g_FHStorage[2*1024]; /* 16KiB */
121int64_t g_DHStorage[512]; /* 4KiB */
122
123VOID OrbisInit()
124{
125 static bool initialised = false;
126
127 if( initialised ) return;
128 initialised = true;
129
130 sceSysmoduleLoadModule(SCE_SYSMODULE_PNG_ENC);
131 sceSysmoduleLoadModule(SCE_SYSMODULE_PNG_DEC);
132 sceSysmoduleLoadModule(SCE_SYSMODULE_APP_CONTENT);
133 sceSysmoduleLoadModule(SCE_SYSMODULE_SAVE_DATA_DIALOG);
134 sceSysmoduleLoadModule(SCE_SYSMODULE_IME_DIALOG);
135 sceSysmoduleLoadModule(SCE_SYSMODULE_RUDP);
136 sceSysmoduleLoadModule(SCE_SYSMODULE_NP_MATCHING2);
137 sceSysmoduleLoadModule(SCE_SYSMODULE_INVITATION_DIALOG);
138 sceSysmoduleLoadModule(SCE_SYSMODULE_NP_PARTY );
139 sceSysmoduleLoadModule(SCE_SYSMODULE_GAME_CUSTOM_DATA_DIALOG );
140 sceSysmoduleLoadModule(SCE_SYSMODULE_NP_SCORE_RANKING );
141 sceSysmoduleLoadModule(SCE_SYSMODULE_NP_AUTH );
142 sceSysmoduleLoadModule(SCE_SYSMODULE_NP_COMMERCE);
143 sceSysmoduleLoadModule(SCE_SYSMODULE_REMOTE_PLAY);
144 sceSysmoduleLoadModule(SCE_SYSMODULE_ERROR_DIALOG);
145 sceSysmoduleLoadModule(SCE_SYSMODULE_MESSAGE_DIALOG);
146 sceSysmoduleLoadModule(SCE_SYSMODULE_VOICE);
147 sceSysmoduleLoadModule(SCE_SYSMODULE_GAME_LIVE_STREAMING);
148
149 SceFiosParams fiosParams = SCE_FIOS_PARAMS_INITIALIZER;
150 fiosParams.opStorage.pPtr = g_OpStorage;
151 fiosParams.opStorage.length = sizeof(g_OpStorage);
152 fiosParams.chunkStorage.pPtr = g_ChunkStorage;
153 fiosParams.chunkStorage.length = sizeof(g_ChunkStorage);
154 fiosParams.fhStorage.pPtr = g_FHStorage;
155 fiosParams.fhStorage.length = sizeof(g_FHStorage);
156 fiosParams.dhStorage.pPtr = g_DHStorage;
157 fiosParams.dhStorage.length = sizeof(g_DHStorage);
158
159 int err = sceFiosInitialize(&fiosParams);
160 assert(err == SCE_FIOS_OK);
161
162 scePthreadMutexattrInit(&mutexParams);
163 scePthreadMutexattrSettype(&mutexParams, SCE_PTHREAD_MUTEX_ADAPTIVE);
164#ifdef USE_RAZOR
165 const int RAZOR_BUFFER_SIZE = 65536;
166 void *razorMem = malloc(RAZOR_BUFFER_SIZE);
167 err = sceRazorCpuInit(razorMem, RAZOR_BUFFER_SIZE);
168 assert(err == 0 );
169#endif
170 scePthreadSetaffinity(scePthreadSelf(), 1);
171
172 sceAudioOutInit();
173 hBGMAudio=sceAudioOutOpen(
174 SCE_USER_SERVICE_USER_ID_SYSTEM,
175 SCE_AUDIO_OUT_PORT_TYPE_BGM,0,
176 256,
177 48000,
178 2);
179
180 err = sceCommonDialogInitialize();
181 //err = sceNpCommerceDialogInitialize();
182 assert(err == SCE_OK);
183
184 // 4J-PB - Can't keep this initialised as we monitor and handle the finished status in the main menu for patches
185// err = sceErrorDialogInitialize();
186// assert(err == SCE_OK);
187
188 // 4J-PB - can't init this here - it conflicts with the commerce dialog for dlc checkouts/PSPlus upsells. We need to init it when we use it, and then terminate it.
189 //err = sceMsgDialogInitialize();
190 assert(err == SCE_OK);
191}
192
193int32_t GetAudioBGMHandle()
194{
195 return hBGMAudio;
196}
197
198VOID InitializeCriticalSection(PCRITICAL_SECTION CriticalSection)
199{
200 char name[1] = {0};
201
202 int err = scePthreadMutexInit(&CriticalSection->mutex, &mutexParams, name);
203 CriticalSection->m_cLock = 0;
204 assert(err == SCE_OK);
205#ifdef _DEBUG
206 CriticalSection->m_pOwnerThread = NULL;
207#endif
208
209}
210
211
212VOID InitializeCriticalSectionAndSpinCount(PCRITICAL_SECTION CriticalSection, ULONG SpinCount)
213{
214 InitializeCriticalSection(CriticalSection);
215}
216
217VOID DeleteCriticalSection(PCRITICAL_SECTION CriticalSection)
218{
219 int err = scePthreadMutexDestroy(&CriticalSection->mutex);
220 assert(err == SCE_OK);
221}
222
223extern CRITICAL_SECTION g_singleThreadCS;
224
225VOID EnterCriticalSection(PCRITICAL_SECTION CriticalSection)
226{
227 int err = scePthreadMutexLock(&CriticalSection->mutex);
228 assert(err == SCE_OK || err == SCE_KERNEL_ERROR_EDEADLK );
229 CriticalSection->m_cLock++;
230
231#ifdef _DEBUG
232 __thread static bool bRecursing = false;
233 if(bRecursing == false)
234 {
235 bRecursing = true;
236 CriticalSection->m_pOwnerThread = C4JThread::getCurrentThread();
237 bRecursing = false;
238 }
239#endif
240}
241
242
243VOID LeaveCriticalSection(PCRITICAL_SECTION CriticalSection)
244{
245 if(--CriticalSection->m_cLock == 0 )
246 {
247 int err = scePthreadMutexUnlock(&CriticalSection->mutex);
248 assert(err == SCE_OK );
249#ifdef _DEBUG
250 CriticalSection->m_pOwnerThread = NULL;
251#endif
252
253 }
254}
255
256ULONG TryEnterCriticalSection(PCRITICAL_SECTION CriticalSection)
257{
258 int err = scePthreadMutexTrylock(&CriticalSection->mutex);
259 if((err == SCE_OK || err == SCE_KERNEL_ERROR_EDEADLK ))
260 {
261 CriticalSection->m_cLock++;
262 return true;
263 }
264 return false;
265}
266
267DWORD WaitForMultipleObjects(DWORD nCount, CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds) { ORBIS_STUBBED; return 0; }
268
269BOOL CloseHandle(HANDLE hObject)
270{
271 sceFiosFHCloseSync(NULL,(SceFiosFH)((int64_t)hObject));
272 return true;
273// ORBIS_STUBBED;
274// return false;
275}
276
277BOOL SetEvent(HANDLE hEvent) { ORBIS_STUBBED; return false; }
278
279HMODULE GetModuleHandle(LPCSTR lpModuleName) { ORBIS_STUBBED; return 0; }
280
281DWORD GetCurrentThreadId(VOID)
282{
283 return 0; // TODO
284}
285DWORD WaitForMultipleObjectsEx(DWORD nCount,CONST HANDLE *lpHandles,BOOL bWaitAll,DWORD dwMilliseconds,BOOL bAlertable ) { ORBIS_STUBBED; return 0; }
286BOOL GetExitCodeThread(HANDLE hThread, LPDWORD lpExitCode) { ORBIS_STUBBED; return false;}
287
288DWORD TlsAlloc(VOID) { return TLSStorageOrbis::Instance()->Alloc(); }
289BOOL TlsFree(DWORD dwTlsIndex) { return TLSStorageOrbis::Instance()->Free(dwTlsIndex); }
290LPVOID TlsGetValue(DWORD dwTlsIndex) { return TLSStorageOrbis::Instance()->GetValue(dwTlsIndex); }
291BOOL TlsSetValue(DWORD dwTlsIndex, LPVOID lpTlsValue) { return TLSStorageOrbis::Instance()->SetValue(dwTlsIndex, lpTlsValue); }
292
293
294// we have to manage our own virtual allocs here, so this class stores all the info for each of them
295class OrbisVAlloc
296{
297public:
298 class PageInfo
299 {
300 public:
301 off_t m_physAddr;
302 void* m_virtualAddr;
303 uint64_t m_size;
304
305 PageInfo(off_t physAddr, void* virtualAddr, uint64_t size)
306 : m_physAddr(physAddr)
307 , m_virtualAddr(virtualAddr)
308 , m_size(size)
309 {}
310 };
311 void* m_virtualAddr;
312 uint64_t m_virtualSize;
313 std::vector<PageInfo> m_pagesAllocated;
314 uint64_t m_allocatedSize;
315
316 OrbisVAlloc(void* addr, uint64_t size)
317 : m_virtualAddr(addr)
318 , m_virtualSize(size)
319 , m_allocatedSize(0)
320 {
321 }
322
323 ~OrbisVAlloc()
324 {
325 Decommit();
326 int err = sceKernelMunmap(m_virtualAddr, m_virtualSize);
327 assert( err == SCE_OK );
328 }
329
330 void* Commit(uint64_t size)
331 {
332 uint64_t sizeToAdd = size - m_allocatedSize; // the extra memory size that we have to add on
333 assert(sizeToAdd >= 0);
334
335 if(sizeToAdd == 0)
336 return m_virtualAddr; // nothing to add
337
338
339 off_t physAddr;
340 // Allocate the physical memory here
341 int err = sceKernelAllocateDirectMemory( 0, SCE_KERNEL_MAIN_DMEM_SIZE, sizeToAdd, 16*1024, SCE_KERNEL_WB_ONION, &physAddr);
342 if(err != SCE_OK)
343 {
344 assert(0);
345 return NULL;
346 }
347 // work out where the next page should be in virtual addr space, and pass that to the mapping function
348 void* pageVirtualAddr = ((char*)m_virtualAddr) + m_allocatedSize;
349
350 void* inAddr = pageVirtualAddr;
351 err = sceKernelMapDirectMemory(
352 &inAddr,
353 sizeToAdd,
354 SCE_KERNEL_PROT_CPU_READ | SCE_KERNEL_PROT_CPU_WRITE,
355 SCE_KERNEL_MAP_FIXED,
356 physAddr,
357 16*1024 );
358
359 if(inAddr != pageVirtualAddr) // make sure we actually get the virtual address that we requested
360 {
361 assert(0);
362 return NULL;
363 }
364 if(err != SCE_OK)
365 {
366 assert(0);
367 return NULL;
368 }
369 m_pagesAllocated.push_back(PageInfo(physAddr, pageVirtualAddr, sizeToAdd));
370 m_allocatedSize += sizeToAdd;
371 return m_virtualAddr;
372 }
373
374
375
376 void Decommit()
377 {
378 // spin round all the pages, unmapping and deallocating them
379 for(int i=0;i<m_pagesAllocated.size();i++)
380 {
381 int err = sceKernelMunmap(m_pagesAllocated[i].m_virtualAddr, m_pagesAllocated[i].m_size);
382 assert(err == SCE_OK);
383 err = sceKernelReleaseDirectMemory(m_pagesAllocated[i].m_physAddr, m_pagesAllocated[i].m_size);
384 assert(err == SCE_OK);
385 }
386 m_pagesAllocated.clear();
387 m_allocatedSize = 0;
388 }
389
390};
391
392// List of all virtual allocs that have been made
393static std::vector<OrbisVAlloc*> s_orbisVAllocs;
394
395
396LPVOID VirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect)
397{
398 if(lpAddress == NULL)
399 {
400 void *pAddr = (void*)SCE_KERNEL_APP_MAP_AREA_START_ADDR;
401 int err = sceKernelReserveVirtualRange(&pAddr, dwSize, 0, 16*1024);
402 if( err != SCE_OK )
403 {
404 app.DebugPrintf("sceKernelReserveVirtualRange failed: 0x%08X\n", err);
405 return NULL;
406 }
407 s_orbisVAllocs.push_back(new OrbisVAlloc(pAddr, dwSize));
408 return (LPVOID)pAddr;
409 }
410 else
411 {
412 if( flAllocationType & MEM_COMMIT )
413 {
414 for(int i=0;i<s_orbisVAllocs.size();i++)
415 {
416 if(s_orbisVAllocs[i]->m_virtualAddr == lpAddress)
417 {
418 return s_orbisVAllocs[i]->Commit(dwSize);
419 }
420 }
421 assert(0); // failed to find the virtual alloc in our table
422 return NULL;
423 }
424 }
425 return NULL;
426}
427
428BOOL VirtualFree(LPVOID lpAddress, SIZE_T dwSize, DWORD dwFreeType)
429{
430 int idx = -1;
431 for(int i=0;i<s_orbisVAllocs.size();i++)
432 {
433 if(s_orbisVAllocs[i]->m_virtualAddr == lpAddress)
434 {
435 idx = i;
436 }
437 }
438
439 assert(idx >= 0);
440 assert(dwSize == s_orbisVAllocs[idx]->m_virtualSize); // only supporting decommitting the entire memory size
441
442 if(dwFreeType == MEM_DECOMMIT)
443 {
444 s_orbisVAllocs[idx]->Decommit();
445 }
446 else if(dwFreeType == MEM_RELEASE)
447 {
448 delete s_orbisVAllocs[idx];
449 s_orbisVAllocs.erase(s_orbisVAllocs.begin()+idx);
450 }
451
452 return TRUE;
453}
454
455DWORD GetFileSize( HANDLE hFile, LPDWORD lpFileSizeHigh )
456{
457 SceFiosSize FileSize;
458 SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
459 //DWORD FileSizeLow;
460 FileSize=sceFiosFHGetSize(fh);
461 if(lpFileSizeHigh)
462 *lpFileSizeHigh= (DWORD)(FileSize>>32);
463 else
464 {
465 assert(FileSize>>32 == 0);
466 }
467
468 return (DWORD)FileSize;
469}
470
471BOOL GetFileSizeEx(HANDLE hFile, PLARGE_INTEGER lpFileSize )
472{
473 SceFiosSize FileSize;
474 SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
475
476 FileSize=sceFiosFHGetSize(fh);
477 lpFileSize->QuadPart=FileSize;
478
479 return true;
480}
481BOOL WriteFile(
482 HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped )
483{
484 SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
485 // sceFiosFHReadSync - Non-negative values are the number of bytes read, 0 <= result <= length. Negative values are error codes.
486 SceFiosSize bytesRead = sceFiosFHWriteSync(NULL, fh, lpBuffer, (SceFiosSize)nNumberOfBytesToWrite);
487 if(bytesRead < 0)
488 {
489 // error
490 return FALSE;
491 }
492 else
493 {
494 *lpNumberOfBytesWritten = (DWORD)bytesRead;
495 return TRUE;
496 }
497}
498
499BOOL ReadFile(HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped )
500{
501 SceFiosFH fh = (SceFiosFH)((int64_t)hFile);
502 // sceFiosFHReadSync - Non-negative values are the number of bytes read, 0 <= result <= length. Negative values are error codes.
503 SceFiosSize bytesRead = sceFiosFHReadSync(NULL, fh, lpBuffer, (SceFiosSize)nNumberOfBytesToRead);
504 *lpNumberOfBytesRead = (DWORD)bytesRead;
505 if(bytesRead < 0)
506 {
507 // error
508 return FALSE;
509 }
510 else
511 {
512 return TRUE;
513 }
514}
515
516BOOL SetFilePointer(HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
517{
518 SceFiosFH fd = (SceFiosFH)((int64_t)hFile);
519
520 uint64_t bitsToMove = (int64_t) lDistanceToMove;
521 SceFiosOffset pos = 0;
522
523 if (lpDistanceToMoveHigh != NULL)
524 bitsToMove |= ((uint64_t) (*lpDistanceToMoveHigh)) << 32;
525
526 SceFiosWhence whence = SCE_FIOS_SEEK_SET;
527 switch(dwMoveMethod)
528 {
529 case FILE_BEGIN: whence = SCE_FIOS_SEEK_SET; break;
530 case FILE_CURRENT: whence = SCE_FIOS_SEEK_CUR; break;
531 case FILE_END: whence = SCE_FIOS_SEEK_END; break;
532 };
533
534 pos = sceFiosFHSeek(fd, (int64_t) lDistanceToMove, whence);
535
536 return (pos != -1);
537}
538
539
540HANDLE CreateFileA(LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
541{
542 char filePath[256];
543 std::string mountedPath = StorageManager.GetMountedPath(lpFileName);
544 if(mountedPath.length() > 0)
545 {
546 strcpy(filePath, mountedPath.c_str());
547 }
548 else if(lpFileName[0] == '/') // already fully qualified path
549 strcpy(filePath, lpFileName );
550 else
551 sprintf(filePath,"%s/%s",getUsrDirPath(), lpFileName );
552
553#ifndef _CONTENT_PACKAGE
554 app.DebugPrintf("*** Opening %s\n",filePath);
555#endif
556
557 SceFiosFH fh;
558 SceFiosOpenParams openParams;
559 ZeroMemory(&openParams, sizeof(SceFiosOpenParams));
560
561 switch(dwDesiredAccess)
562 {
563 case GENERIC_READ:
564 openParams.openFlags = SCE_FIOS_O_RDONLY; break;
565 case GENERIC_WRITE:
566 openParams.openFlags = SCE_FIOS_O_WRONLY; break;
567 default:
568 openParams.openFlags = SCE_FIOS_O_READ | SCE_FIOS_O_WRITE; break;
569 }
570
571 switch(dwCreationDisposition)
572 {
573 case CREATE_ALWAYS:
574 openParams.openFlags |= SCE_FIOS_O_CREAT; break;
575 case CREATE_NEW:
576 openParams.openFlags |= SCE_FIOS_O_CREAT; break;
577 case OPEN_ALWAYS:
578 openParams.openFlags |= SCE_FIOS_O_CREAT; break;
579 case OPEN_EXISTING:
580 break;
581 case TRUNCATE_EXISTING:
582 break;
583 }
584 int err = sceFiosFHOpenSync(NULL, &fh, filePath, &openParams);
585
586 if(err != SCE_FIOS_OK)
587 {
588 return INVALID_HANDLE_VALUE;
589 }
590 //assert( err == SCE_FIOS_OK );
591
592 return (void*)fh;
593}
594
595BOOL CreateDirectoryA(LPCSTR lpPathName, LPSECURITY_ATTRIBUTES lpSecurityAttributes){ ORBIS_STUBBED; return false; }
596BOOL DeleteFileA(LPCSTR lpFileName) { ORBIS_STUBBED; return false; }
597
598// BOOL XCloseHandle(HANDLE a)
599// {
600// sceFiosFHCloseSync(NULL,(SceFiosFH)((int64_t)a));
601// return true;
602// }
603
604
605DWORD GetFileAttributesA(LPCSTR lpFileName)
606{
607 char filePath[256];
608 std::string mountedPath = StorageManager.GetMountedPath(lpFileName);
609 if(mountedPath.length() > 0)
610 {
611 strcpy(filePath, mountedPath.c_str());
612 }
613 else if(lpFileName[0] == '/') // already fully qualified path
614 strcpy(filePath, lpFileName );
615 else
616 sprintf(filePath,"%s/%s",getUsrDirPath(), lpFileName ); // set to load from host
617
618 // check if the file exists first
619 SceFiosStat statData;
620 if(sceFiosStatSync(NULL, filePath, &statData) != SCE_FIOS_OK)
621 {
622 app.DebugPrintf("*** sceFiosStatSync Failed\n");
623 return -1;
624 }
625 if(statData.statFlags & SCE_FIOS_STATUS_DIRECTORY )
626 return FILE_ATTRIBUTE_DIRECTORY;
627 else
628 return FILE_ATTRIBUTE_NORMAL;
629}
630
631
632BOOL MoveFileA(LPCSTR lpExistingFileName, LPCSTR lpNewFileName) { ORBIS_STUBBED; return false; }
633
634
635DWORD GetLastError(VOID) { ORBIS_STUBBED; return 0; }
636VOID GlobalMemoryStatus(LPMEMORYSTATUS lpBuffer)
637{
638 SceLibcMallocManagedSize stat;
639 int err = malloc_stats(&stat);
640 if(err != 0)
641 {
642 app.DebugPrintf("Failed to get mem stats\n");
643 }
644
645 lpBuffer->dwTotalPhys = stat.maxSystemSize;
646 lpBuffer->dwAvailPhys = stat.maxSystemSize - stat.currentSystemSize;
647 lpBuffer->dwAvailVirtual = stat.maxSystemSize - stat.currentInuseSize;
648}
649
650DWORD GetTickCount()
651{
652 // This function returns the current system time at this function is called.
653 // The system time is represented the time elapsed since the system starts up in microseconds.
654 uint64_t sysTime = sceKernelGetProcessTime();
655 return (DWORD)(sysTime / 1000);
656}
657
658// we should really use libperf for this kind of thing, but this will do for now.
659BOOL QueryPerformanceFrequency(LARGE_INTEGER *lpFrequency)
660{
661 // microseconds
662 lpFrequency->QuadPart = (1000 * 1000);
663 return false;
664}
665BOOL QueryPerformanceCounter(LARGE_INTEGER *lpPerformanceCount)
666{
667 // microseconds
668 lpPerformanceCount->QuadPart = sceKernelGetProcessTime();
669 return true;
670}
671
672#ifndef _FINAL_BUILD
673
674VOID OutputDebugStringW(LPCWSTR lpOutputString)
675{
676 wprintf(lpOutputString);
677}
678
679VOID OutputDebugStringA(LPCSTR lpOutputString)
680{
681 printf(lpOutputString);
682}
683
684VOID OutputDebugString(LPCSTR lpOutputString)
685{
686 printf(lpOutputString);
687}
688#endif // _CONTENT_PACKAGE
689
690BOOL GetFileAttributesExA(LPCSTR lpFileName,GET_FILEEX_INFO_LEVELS fInfoLevelId,LPVOID lpFileInformation)
691{
692 ORBIS_STUBBED;
693 return false;
694}
695HANDLE FindFirstFileA(LPCSTR lpFileName, LPWIN32_FIND_DATA lpFindFileData) { ORBIS_STUBBED; return 0;}
696BOOL FindNextFileA(HANDLE hFindFile, LPWIN32_FIND_DATAA lpFindFileData) { ORBIS_STUBBED; return false;}
697
698errno_t _itoa_s(int _Value, char * _DstBuf, size_t _Size, int _Radix) { if(_Radix==10) sprintf(_DstBuf,"%d",_Value); else if(_Radix==16) sprintf(_DstBuf,"%lx",_Value); else return -1; return 0; }
699errno_t _i64toa_s(__int64 _Val, char * _DstBuf, size_t _Size, int _Radix) { if(_Radix==10) sprintf(_DstBuf,"%lld",_Val); else return -1; return 0; }
700
701DWORD XGetLanguage()
702{
703 unsigned char ucLang = app.GetMinecraftLanguage(0);
704 int iLang;
705
706 // check if we should override the system language or not
707 if(ucLang==MINECRAFT_LANGUAGE_DEFAULT)
708 {
709 sceSystemServiceParamGetInt(SCE_SYSTEM_SERVICE_PARAM_ID_LANG,&iLang);
710 }
711 else
712 {
713 return (DWORD)ucLang;
714 }
715
716 switch(iLang)
717 {
718 case SCE_SYSTEM_PARAM_LANG_JAPANESE : return XC_LANGUAGE_JAPANESE;
719 case SCE_SYSTEM_PARAM_LANG_ENGLISH_US : return XC_LANGUAGE_ENGLISH;
720 case SCE_SYSTEM_PARAM_LANG_FRENCH : return XC_LANGUAGE_FRENCH;
721
722 case SCE_SYSTEM_PARAM_LANG_SPANISH : return XC_LANGUAGE_SPANISH;
723 case SCE_SYSTEM_PARAM_LANG_SPANISH_LA : return XC_LANGUAGE_LATINAMERICANSPANISH;
724
725 case SCE_SYSTEM_PARAM_LANG_GERMAN : return XC_LANGUAGE_GERMAN;
726 case SCE_SYSTEM_PARAM_LANG_ITALIAN : return XC_LANGUAGE_ITALIAN;
727 case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_PT : return XC_LANGUAGE_PORTUGUESE;
728
729 case SCE_SYSTEM_PARAM_LANG_RUSSIAN : return XC_LANGUAGE_RUSSIAN;
730 case SCE_SYSTEM_PARAM_LANG_KOREAN : return XC_LANGUAGE_KOREAN;
731 case SCE_SYSTEM_PARAM_LANG_CHINESE_T : return XC_LANGUAGE_TCHINESE;
732 case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_BR : return XC_LANGUAGE_PORTUGUESE;
733 case SCE_SYSTEM_PARAM_LANG_ENGLISH_GB : return XC_LANGUAGE_ENGLISH;
734
735 case SCE_SYSTEM_PARAM_LANG_DUTCH : return XC_LANGUAGE_DUTCH;
736 case SCE_SYSTEM_PARAM_LANG_FINNISH : return XC_LANGUAGE_FINISH;
737 case SCE_SYSTEM_PARAM_LANG_SWEDISH : return XC_LANGUAGE_SWEDISH;
738 case SCE_SYSTEM_PARAM_LANG_DANISH : return XC_LANGUAGE_DANISH;
739 case SCE_SYSTEM_PARAM_LANG_NORWEGIAN : return XC_LANGUAGE_BNORWEGIAN;
740 case SCE_SYSTEM_PARAM_LANG_POLISH : return XC_LANGUAGE_POLISH;
741 case SCE_SYSTEM_PARAM_LANG_TURKISH : return XC_LANGUAGE_TURKISH;
742
743
744 case SCE_SYSTEM_PARAM_LANG_CHINESE_S : return XC_LANGUAGE_SCHINESE;
745
746 default : return XC_LANGUAGE_ENGLISH;
747 }
748
749}
750DWORD XGetLocale()
751{
752 int iLang;
753 sceSystemServiceParamGetInt(SCE_SYSTEM_SERVICE_PARAM_ID_LANG,&iLang);
754 switch(iLang)
755 {
756 case SCE_SYSTEM_PARAM_LANG_JAPANESE : return XC_LOCALE_JAPAN;
757 case SCE_SYSTEM_PARAM_LANG_ENGLISH_US : return XC_LOCALE_UNITED_STATES;
758 case SCE_SYSTEM_PARAM_LANG_FRENCH : return XC_LOCALE_FRANCE;
759
760 case SCE_SYSTEM_PARAM_LANG_SPANISH : return XC_LOCALE_SPAIN;
761 case SCE_SYSTEM_PARAM_LANG_SPANISH_LA : return XC_LOCALE_LATIN_AMERICA;
762
763 case SCE_SYSTEM_PARAM_LANG_GERMAN : return XC_LOCALE_GERMANY;
764 case SCE_SYSTEM_PARAM_LANG_ITALIAN : return XC_LOCALE_ITALY;
765 case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_PT : return XC_LOCALE_PORTUGAL;
766
767 case SCE_SYSTEM_PARAM_LANG_RUSSIAN : return XC_LOCALE_RUSSIAN_FEDERATION;
768 case SCE_SYSTEM_PARAM_LANG_KOREAN : return XC_LOCALE_KOREA;
769 case SCE_SYSTEM_PARAM_LANG_CHINESE_T : return XC_LOCALE_CHINA;
770 case SCE_SYSTEM_PARAM_LANG_PORTUGUESE_BR : return XC_LOCALE_BRAZIL;
771 case SCE_SYSTEM_PARAM_LANG_ENGLISH_GB : return XC_LOCALE_GREAT_BRITAIN;
772
773 case SCE_SYSTEM_PARAM_LANG_DUTCH : return XC_LOCALE_NETHERLANDS;
774 case SCE_SYSTEM_PARAM_LANG_FINNISH : return XC_LOCALE_FINLAND;
775 case SCE_SYSTEM_PARAM_LANG_SWEDISH : return XC_LOCALE_SWEDEN;
776 case SCE_SYSTEM_PARAM_LANG_DANISH : return XC_LOCALE_DENMARK;
777 case SCE_SYSTEM_PARAM_LANG_NORWEGIAN : return XC_LOCALE_NORWAY;
778 case SCE_SYSTEM_PARAM_LANG_POLISH : return XC_LOCALE_POLAND;
779 case SCE_SYSTEM_PARAM_LANG_TURKISH : return XC_LOCALE_TURKEY;
780
781
782 case SCE_SYSTEM_PARAM_LANG_CHINESE_S : return XC_LOCALE_CHINA;
783 default : return XC_LOCALE_UNITED_STATES;
784 }
785}
786
787DWORD XEnableGuestSignin(BOOL fEnable)
788{
789 return 0;
790}