static void TalkPoll()
{
if(!rainin)
{
rainin=_fsopen(raincmdname,"rt",SH_DENYNO);
if(rainin) setbuf(rainin,NULL);
}
if(rainin)
{
ParseString("0"); //just 50 or more Hz polling with no command
a:
fgets(input+inputlen,MAX_LINE_LENGTH-inputlen,rainin);
inputlen+=strlen(input+inputlen);
if ((inputlen && input[inputlen-1]=='\n') || inputlen>=MAX_LINE_LENGTH-1)
{
ParseString(input); //parse real command
inputlen=0;
input[0]=0;
goto a; //parse all commands until end of file
}
}
{
char *err;
while (err=errGet())
{
fprintf(rainout,"%s\n",err);
free(err);
}
}
}
FILE *
Fopen(const char *name, const char *mode)
{
FILE *fd;
if (db2) printf(">>> Fopen '%s', mode '%s'\n", name, mode);
#if defined(_WIN32)
fd = _fsopen(name, mode, _SH_DENYNO);
#else
fd = fopen(name, mode);
#endif
if (fd == NULL) {
printf("<<< Fopen failed on '%s', mode '%s'\n", name, mode);
return ((FILE*) NULL);
}
if (strncmp(mode, "a", 1) == 0) {
if (db3) printf("* Append mode, seeking to end.\n");
fseek(fd, 0L, SEEK_SET);
}
if (db2) printf("<<< Fopen: '%s'\n", name);
return(fd);
}
void Log(const char szFormat[], ...)
{
if (0 == g_strListFileName[0])
return;
static FILE *f = NULL;
const char *mode;
if (g_bListFileAppend)
mode = "a";
else
mode = "w";
if (NULL == f)
f = _fsopen(g_strListFileName, mode, _SH_DENYNO);
if (NULL == f)
{
perror(g_strListFileName);
exit(EXIT_NotStarted);
}
char szStr[4096];
va_list ArgList;
va_start(ArgList, szFormat);
vsprintf(szStr, szFormat, ArgList);
fprintf(f, "%s", szStr);
fflush(f);
}
void Log(char* szFormat, ...)
{
va_list vaArgs;
va_start(vaArgs, szFormat);
int len = _vscprintf(szFormat, vaArgs);
char* szString = new char[len+1];
vsprintf_s(szString, len+1, szFormat, vaArgs);
va_end(vaArgs);
time_t tTime;
time(&tTime);
char szTime[128] = "";
struct tm time;
localtime_s(&time, &tTime);
strftime(szTime, sizeof(szTime), "%x %X", &time);
char path[_MAX_PATH+_MAX_FNAME] = "";
sprintf_s(path, sizeof(path), "%sd2bs.log", Vars.szPath);
#ifdef DEBUG
FILE* log = stderr;
#else
FILE* log = _fsopen(path, "a+", _SH_DENYNO);
#endif
fprintf(log, "[%s] D2BS %d: %s\n", szTime, GetProcessId(GetCurrentProcess()), szString);
#ifndef DEBUG
fflush(log);
fclose(log);
#endif
delete[] szString;
}
int EsifLogFile_Open(EsifLogType type, const char *filename, int append)
{
int rc=0;
char fullpath[MAX_PATH]={0};
char mode[3] = {(append ? 'a' : 'w'), 0, 0};
esif_ccb_write_lock(&g_EsifLogFile[type].lock);
if (g_EsifLogFile[type].handle != NULL)
esif_ccb_fclose(g_EsifLogFile[type].handle);
EsifLogFile_GetFullPath(fullpath, sizeof(fullpath), filename);
#ifdef ESIF_ATTR_OS_WINDOWS
mode[1] = 'c';
g_EsifLogFile[type].handle = _fsopen(fullpath, mode, _SH_DENYWR);
if (g_EsifLogFile[type].handle == NULL)
rc = errno;
#else
rc = esif_ccb_fopen(&g_EsifLogFile[type].handle, fullpath, mode);
#endif
if (rc == 0) {
esif_ccb_free(g_EsifLogFile[type].filename);
g_EsifLogFile[type].filename = esif_ccb_strdup((char *)fullpath);
}
esif_ccb_write_unlock(&g_EsifLogFile[type].lock);
return rc;
}
void start_log(void) {
if (log_fp!=NULL)
return;
CSLock lock(log_critsec);
CString fn = p_filenames->LogFilename();
// Check, if file exists and size is too large
struct stat file_stats = { 0 };
if (stat(fn.GetString(), &file_stats) == 0)
{
unsigned long int max_file_size = 1E06 * preferences.log_max_logsize();
size_t file_size = file_stats.st_size;
if (file_size > max_file_size)
{
remove(fn.GetString());
}
}
// Append (or create) log
if ((log_fp = _fsopen(fn.GetString(), "a", _SH_DENYWR)) != 0) {
write_log_separator(k_always_log_basic_information, "LOG FILE OPEN");
fflush(log_fp);
}
}
bool OpenLog()
{
// open
sLogFileName = C4CFN_Log; int iLog = 2;
#ifdef _WIN32
while (!(C4LogFile = _fsopen(Config.AtUserDataPath(sLogFileName.getData()), "wt", _SH_DENYWR)))
#elif defined(HAVE_SYS_FILE_H)
int fd = 0;
while (!(fd = open(Config.AtUserDataPath(sLogFileName.getData()), O_WRONLY | O_CREAT, 0644)) || flock(fd, LOCK_EX|LOCK_NB))
#else
while (!(C4LogFile = fopen(Config.AtUserDataPath(sLogFileName.getData()), "wb")))
#endif
{
// Already locked by another instance?
#if !defined(_WIN32) && defined(HAVE_SYS_FILE_H)
if (fd) close(fd);
#else
if (C4LogFile) fclose(C4LogFile);
#endif
// If the file does not yet exist, the directory is r/o
// don't go on then, or we have an infinite loop
if (access(Config.AtUserDataPath(sLogFileName.getData()), 0))
return false;
// try different name
sLogFileName.Format(C4CFN_LogEx, iLog++);
}
#if !defined(_WIN32) && defined(HAVE_SYS_FILE_H)
ftruncate(fd, 0);
C4LogFile = fdopen(fd, "wb");
#endif
// save start time
time(&C4LogStartTime);
return true;
}
// which music was playing on last quitting
static void recored_list_log(int curidx)
{
FILE* pf = _fsopen("list.record", "wb+", _SH_DENYNO);
fwrite(&curidx, sizeof(curidx), 1, pf);
fclose(pf);
pf = NULL;
}
static void init_dbgfp()
{
#if _DBG
if (!dbgfp) {
#if (!HIME_IME || 1) && !CONSOLE_OFF
AllocConsole();
fclose(stdout);
fclose(stderr);
int fh = _open_osfhandle((long)GetStdHandle(STD_OUTPUT_HANDLE), 0);
_dup2(fh, 1);
_dup2(fh, 2);
_fdopen(1, "wt");
_fdopen(2, "wt");
fflush(stdout);
#endif
char tt[512];
#if HIME_IME
sprintf(tt, "C:\\dbg\\ime%x", GetCurrentProcessId());
#elif HIME_SVR
sprintf(tt, "C:\\dbg\\svr%x", GetCurrentProcessId());
#else
sprintf(tt, "C:\\dbg\\other%x", GetCurrentProcessId());
#endif
dbgfp=_fsopen(tt, "wt", _SH_DENYWR);
setbuf(dbgfp, NULL);
char exe[MAX_PATH];
GetModuleFileNameA(NULL, exe, sizeof(exe));
dbg("started %s\n", exe);
}
#endif
}
// ----------------------------------------------------------------------------
//
bool SpotifyEngine::_readCredentials( CString& username, CString& credentials )
{
CString filename;
filename.Format( "%s\\DMXStudio\\SpotifyCredentials", getUserDocumentDirectory() );
username.Empty();
credentials.Empty();
if ( GetFileAttributes( filename ) == INVALID_FILE_ATTRIBUTES )
return false;
FILE* hFile = _fsopen( filename, "rt", _SH_DENYWR );
if ( hFile == NULL )
return false;
LPSTR lpUsername = username.GetBufferSetLength( 256 );
LPSTR lpCredentials = credentials.GetBufferSetLength( 2048 );
size_t read = fscanf_s( hFile, "%s %s", lpUsername, 256, lpCredentials, 256 );
username.ReleaseBuffer();
credentials.ReleaseBuffer();
fclose( hFile );
return read == 2;
}
void start_log(void)
{
if (log_fp!=NULL)
return;
CSLock lock(log_critsec);
CString fn = p_filenames->LogFilename();
// Check, if file exists and size is too large
struct stat file_stats = { 0 };
if (stat(fn.GetString(), &file_stats) == 0)
{
unsigned long int max_file_size = 1E06 * prefs.log_max_logsize();
size_t file_size = file_stats.st_size;
if (file_size > max_file_size)
{
remove(fn.GetString());
}
}
// Append (or create) log
if ((log_fp = _fsopen(fn.GetString(), "a", _SH_DENYWR)) != 0)
{
write_log(k_always_log_basic_information, "! log file open\n");
fprintf(log_fp, "yyyy.mm.dd hh:mm:ss - # hand commoncard rank poker win los tie P nit bestaction - play* call bet pot balance - FCKRA FCKRA swag\n"); //!! nit fprintf(log_fp, "----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
fflush(log_fp);
}
}
FILE *sh_fopen (char *filename, char *access, int shmode)
{
FILE *fp;
#if !defined(__LINUX__)
long t1, t2;
#endif
#if defined(__LINUX__)
fp = fopen (filename, access);
shmode = shmode;
#else
t1 = time (NULL);
while (time (NULL) < t1 + 20) {
if ((fp = _fsopen (filename, access, shmode)) != NULL)
break;
#if !defined(__LINUX__)
if (errno != EACCES)
break;
#endif
t2 = time (NULL);
while (time (NULL) < t2 + 1)
;
}
#endif
return (fp);
}
FILE *openLog(const char *func, const char *file, int line) {
char timestamp[TIMESTAMP_BUFFER_LEN];
#ifdef _WIN32
char delimiter = '\\';
SYSTEMTIME now;
FILE *log;
GetLocalTime(&now);
sprintf_s(timestamp, TIMESTAMP_BUFFER_LEN, "%d-%02d-%02d %02d:%02d:%02d.%03d", now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond, now.wMilliseconds);
#else
char delimiter = '/';
struct timeval tv;
time_t curtime;
gettimeofday(&tv, NULL);
curtime = tv.tv_sec;
strftime(timestamp, 30, "%Y-%m-%d %T", localtime(&curtime));
#ifdef __APPLE__
sprintf(timestamp + strlen(timestamp), ".%03i ", tv.tv_usec / 1000);
#else
sprintf(timestamp + strlen(timestamp), ".%03li ", tv.tv_usec / 1000);
#endif
#endif
#ifndef _WIN32
FILE *log = fopen(getLogFilename(), "a");
#else
log = _fsopen(getLogFilename(), "a", _SH_DENYNO);
#endif
fprintf(log, "%s ", timestamp);
if (file) {
char *f = strrchr((char *)file, delimiter);
if (!f) f = (char *)file;
else f++;
fprintf(log, "%s() [%s:%i] ", func, f, line);
}
return log;
}
void write_log_pokertracker(int level, char* fmt, ...)
{
char buff[10000] ;
va_list ap;
char nowtime[26];
FILE *fp=NULL;
if (level>prefs.log_level_pt())
return;
CString fn;
fn.Format("%s\\oh_pt_%lu.log", _startup_path, p_sessioncounter->session_id());
if ((fp = _fsopen(fn.GetString(), "a", _SH_DENYWR)) != 0)
{
va_start(ap, fmt);
vsprintf_s(buff, 10000, fmt, ap);
get_time(nowtime);
fprintf(fp, "%s - %s", nowtime, buff);
va_end(ap);
fflush(fp);
fclose(fp);
}
}
nfsstat3 CNFS3Prog::ProcedureWRITE(void)
{
char *path;
offset3 offset;
count3 count;
stable_how stable;
opaque data;
wcc_data file_wcc;
writeverf3 verf;
nfsstat3 stat;
FILE *pFile;
PrintLog("WRITE");
path = GetPath();
Read(&offset);
Read(&count);
Read(&stable);
Read(&data);
stat = CheckFile(path);
file_wcc.before.attributes_follow = GetFileAttributesForNFS(path, &file_wcc.before.attributes);
if (stat == NFS3_OK) {
pFile = _fsopen(path, "r+b", _SH_DENYWR);
if (pFile != NULL) {
_fseeki64(pFile, offset, SEEK_SET) ;
count = fwrite(data.contents, sizeof(char), data.length, pFile);
fclose(pFile);
} else {
char buffer[BUFFER_SIZE];
errno_t errorNumber = errno;
strerror_s(buffer, BUFFER_SIZE, errorNumber);
PrintLog(buffer);
if (errorNumber == 13) {
stat = NFS3ERR_ACCES;
} else {
stat = NFS3ERR_IO;
}
}
stable = FILE_SYNC;
verf = 0;
}
file_wcc.after.attributes_follow = GetFileAttributesForNFS(path, &file_wcc.after.attributes);
Write(&stat);
Write(&file_wcc);
if (stat == NFS3_OK) {
Write(&count);
Write(&stable);
Write(&verf);
}
return stat;
}
void start_log(void)
{
if (prefs.log_level()==0)
return;
if (log_fp!=NULL)
return;
CString fn;
CSLock lock(log_critsec);
fn.Format("%s\\oh_%lu.log", _startup_path, p_sessioncounter->session_id());
// Check, if file exists and size is too large
if ((log_fp = _fsopen(fn.GetString(), "r", _SH_DENYWR)) != 0)
{
LARGE_INTEGER file_size;
unsigned long int max_file_size = 1E06 * prefs.log_max_logsize();
if (GetFileSizeEx(log_fp, &file_size))
{
if ((file_size.HighPart > 0) || (file_size.LowPart > max_file_size ))
{
fclose(log_fp);
remove(fn.GetString());
}
}
else
{
fclose(log_fp);
}
}
#ifdef DEBUG
OpenDebuggingConsole();
#endif
// Append (or create) log
if ((log_fp = _fsopen(fn.GetString(), "a", _SH_DENYWR)) != 0)
{
write_log(1, "! log file open\n");
fprintf(log_fp, "yyyy.mm.dd hh:mm:ss - # hand commoncard rank poker win los tie P nit bestaction - play* call bet pot balance - FCKRA FCKRA swag\n");
fprintf(log_fp, "----------------------------------------------------------------------------------------------------------------------------------------------------------\n");
fflush(log_fp);
}
}
bool cFile::Open(const AString & iFileName, eMode iMode)
{
ASSERT(!IsOpen()); // You should close the file before opening another one
if (IsOpen())
{
Close();
}
const char * Mode = nullptr;
switch (iMode)
{
case fmRead: Mode = "rb"; break;
case fmWrite: Mode = "wb"; break;
case fmReadWrite: Mode = "rb+"; break;
case fmAppend: Mode = "a+"; break;
}
if (Mode == nullptr)
{
ASSERT(!"Unhandled file mode");
return false;
}
#ifdef _WIN32
m_File = _fsopen((FILE_IO_PREFIX + iFileName).c_str(), Mode, _SH_DENYWR);
#else
m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), Mode);
#endif // _WIN32
if ((m_File == nullptr) && (iMode == fmReadWrite))
{
// Fix for MS not following C spec, opening "a" mode files for writing at the end only
// The file open operation has been tried with "read update", fails if file not found
// So now we know either the file doesn't exist or we don't have rights, no need to worry about file contents.
// Simply re-open for read-writing, erasing existing contents:
#ifdef _WIN32
m_File = _fsopen((FILE_IO_PREFIX + iFileName).c_str(), "wb+", _SH_DENYWR);
#else
m_File = fopen((FILE_IO_PREFIX + iFileName).c_str(), "wb+");
#endif // _WIN32
}
return (m_File != nullptr);
}
/*-------------------------------------------------------------------------*/
APIRET OpenFile( CHAR *netfile )
{
ReadOnly = FALSE;
if(( PktFile = _fsopen( netfile, "rb+", SH_DENYWR )) == NULL )
{
if(( PktFile = _fsopen( netfile, "rb", SH_DENYWR )) == NULL )
{
ShowError( "Can't open file '%s'", ShowPath( netfile, 50 ));
return( ERROR_OPEN_FAILED );
}
ReadOnly = TRUE;
}
setvbuf( PktFile, iobuf, _IOFBF, SIZEIOBUF );
return( NO_ERROR );
}
// ----------------------------------------------------------------------------
//
void SpotifyEngine::_writeCredentials( LPCSTR username, LPCSTR credentials )
{
CString filename;
filename.Format( "%s\\DMXStudio\\SpotifyCredentials", getUserDocumentDirectory() );
FILE* hFile = _fsopen( filename, "wt", _SH_DENYWR );
fprintf( hFile, "%s %s", username, credentials );
fclose( hFile );
}
nfsstat3 CNFS3Prog::ProcedureCREATE(void)
{
char *path;
createhow3 how;
post_op_fh3 obj;
post_op_attr obj_attributes;
wcc_data dir_wcc;
nfsstat3 stat;
FILE *pFile;
PrintLog("CREATE");
std::string dirName;
std::string fileName;
ReadDirectory(dirName, fileName);
path = GetFullPath(dirName, fileName);
Read(&how);
dir_wcc.before.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.before.attributes);
pFile = _fsopen(path, "wb", _SH_DENYWR);
if (pFile != NULL) {
fclose(pFile);
stat = NFS3_OK;
} else {
char buffer[BUFFER_SIZE];
errno_t errorNumber = errno;
strerror_s(buffer, BUFFER_SIZE, errorNumber);
PrintLog(buffer);
if (errorNumber == 2) {
stat = NFS3ERR_STALE;
} else if (errorNumber == 13) {
stat = NFS3ERR_ACCES;
} else {
stat = NFS3ERR_IO;
}
}
if (stat == NFS3_OK) {
obj.handle_follows = GetFileHandle(path, &obj.handle);
obj_attributes.attributes_follow = GetFileAttributesForNFS(path, &obj_attributes.attributes);
}
dir_wcc.after.attributes_follow = GetFileAttributesForNFS((char*)dirName.c_str(), &dir_wcc.after.attributes);
Write(&stat);
if (stat == NFS3_OK) {
Write(&obj);
Write(&obj_attributes);
}
Write(&dir_wcc);
return stat;
}
CBGLog::CBGLog(DWORD dwFileNumber)
{
const std::string strLogName = "BGLog" + std::to_string(dwFileNumber) + ".txt";
std::string strCurrentDir;
GetCurrentPath(strCurrentDir);
m_stLogInfo.strFilePath = strCurrentDir + "\\" + strLogName;
m_stLogInfo.pFile = _fsopen(m_stLogInfo.strFilePath.c_str(), "a+", _SH_DENYNO);
}
// ----------------------------------------------------------------------------
//
AnalyzeInfo* SpotifyEngine::loadTrackAnalysis( LPCSTR spotify_id )
{
TrackAnalysisCache::iterator it = m_track_analysis_cache.find( spotify_id );
if ( it != m_track_analysis_cache.end() )
return (it)->second;
// See if it existing on disk - if available, load into the cache and return
CString filename = makeTrackAnalysisFileName( m_trackAnalysisContainer, spotify_id );
if ( GetFileAttributes( filename ) == INVALID_FILE_ATTRIBUTES )
return NULL;
FILE* hFile = _fsopen( filename, "rt", _SH_DENYWR );
if ( hFile == NULL ) {
log( "Unable to read track analysis from %s", filename );
return NULL;
}
// Get file size
fseek( hFile, 0L, SEEK_END );
size_t size = ftell( hFile );
rewind( hFile );
CString data;
fread( data.GetBufferSetLength(size), 1, size, hFile );
fclose( hFile );
SimpleJsonParser parser;
try {
parser.parse( data );
CString spotify_id = parser.get<CString>( "link" );
SimpleJsonParser amplitute_parser = parser.get<SimpleJsonParser>( "amplitude" );
size_t data_count = amplitute_parser.get<size_t>( "data_count" );
UINT duration_ms = amplitute_parser.get<size_t>( "duration_ms" );
std::vector<uint16_t> amplitude_data = amplitute_parser.getArray<uint16_t>( "data" );
AnalyzeInfo* info = (AnalyzeInfo*)calloc( sizeof(AnalyzeInfo) + (sizeof(uint16_t) * data_count), 1 );
for ( size_t i=0; i < data_count; i++ )
info->data[i] = amplitude_data[i];
strncpy_s( info->link, spotify_id, sizeof(info->link) );
info->data_count = data_count;
info->duration_ms = duration_ms;
m_track_analysis_cache[info->link] = info;
return info;
}
catch ( std::exception& e ) {
log( StudioException( "JSON parser error (%s) data (%s)", e.what(), data ) );
return NULL;
}
}
void yazici_dosyasi_yarat(char *dosya_adi)
{
FILE *fp;
if ((fp = _fsopen(dosya_adi, "wb", SH_DENYNO)) == NULL) {
msj_kutu(NULL, "Disk kay�t hatas�", HATA);
exit(1);
}
fclose(fp);
}
void IDebugLog::Open(const char * path)
{
logFile = _fsopen(path, "w", _SH_DENYWR);
if(!logFile)
{
UInt32 id = 0;
char name[1024];
do
{
sprintf_s(name, sizeof(name), "%s%d", path, id);
id++;
logFile = NULL;
logFile = _fsopen(name, "w", _SH_DENYWR);
}
while(!logFile && (id < 5));
}
}
void dizayn_yukle(char *dosya_adi, char *yazdirma_alani)
{
FILE *fp;
if ((fp = _fsopen(dosya_adi, "rb", SH_DENYNO)) == NULL) {
msj_kutu(dosya_adi_ayir(dosya_adi), HATA_DOSYA_BULUNAMADI, HATA);
exit(1);
}
fseek(fp, 0, SEEK_SET);
fread(yazdirma_alani, 1, 4920, fp);
fclose(fp);
}
void OpenLog( const char *name )
{
#ifdef __UNIX__
LogFile = fopen( name, "w" );
#else
LogFile = _fsopen( name, "w", SH_DENYWR );
#endif
if( LogFile == NULL ) {
Fatal( "Can not open '%s': %s\n", name, strerror( errno ) );
}
setvbuf( LogFile, NULL, _IOLBF, BUFSIZ );
}
nfsstat3 CNFS3Prog::ProcedureREAD(void)
{
char *path;
offset3 offset;
count3 count;
post_op_attr file_attributes;
bool eof;
opaque data;
nfsstat3 stat;
FILE *pFile;
PrintLog("READ");
path = GetPath();
Read(&offset);
Read(&count);
stat = CheckFile(path);
if (stat == NFS3_OK) {
data.SetSize(count);
pFile = _fsopen(path, "rb", _SH_DENYWR);
if (pFile != NULL) {
_fseeki64(pFile, offset, SEEK_SET) ;
count = fread(data.contents, sizeof(char), count, pFile);
eof = fgetc(pFile) == EOF;
fclose(pFile);
} else {
char buffer[BUFFER_SIZE];
errno_t errorNumber = errno;
strerror_s(buffer, BUFFER_SIZE, errorNumber);
PrintLog(buffer);
if (errorNumber == 13) {
stat = NFS3ERR_ACCES;
} else {
stat = NFS3ERR_IO;
}
}
}
file_attributes.attributes_follow = GetFileAttributesForNFS(path, &file_attributes.attributes);
Write(&stat);
Write(&file_attributes);
if (stat == NFS3_OK) {
Write(&count);
Write(&eof);
Write(&data);
}
return stat;
}
void Extension::AppendReceivedBinaryToFile(int Position, int Size, char * Filename)
{
if (Position < 0)
CreateError("Cannot append received binary; Position less than 0.");
else if (Size <= 0)
CreateError("Cannot append received binary; Size equal or less than 0.");
else if (!Filename || Filename[0] == '\0')
CreateError("Cannot append received binary; filename is invalid.");
else if (ThreadData.ReceivedMsg.Size - Size <= 0)
CreateError("Cannot append received binary; Message is too small.");
else
{
// Open while denying write of other programs
FILE * File = _fsopen(Filename, "ab", SH_DENYWR);
if (!File)
{
char errorval[20];
SaveExtInfo &S = AddEvent(0);
std::string Error = "Cannot append received binary to file, error ";
if (_itoa_s(*_errno(), &errorval[0], 20, 10))
{
Error += " with opening the file, and with converting error number.";
}
else
{
Error += "number [";
Error += &errorval[0];
Error += "] occured with opening the file.";
}
Error += "\r\nThe message has not been modified.";
S.Error.Text = _strdup(Error.c_str());
return;
}
long l;
if ((l = fwrite(ThreadData.ReceivedMsg.Content + Position, 1, Size, File)) != Size)
{
char sizeastext[20];
SaveExtInfo &S = AddEvent(0);
std::string Error = "Couldn't append the received binary to file, ";
if (_itoa_s(errno, &sizeastext[0], 20, 10))
{
Error += " and error copying size.";
}
else
{
Error += &sizeastext[0];
Error += " bytes managed to be append.";
}
S.Error.Text = _strdup(Error.c_str());
}
fclose(File);
}
}
bool FileStream::Open(const char* szFileName, const char* szMode, bool sharedHandle)
{
// must not already have a handle open
ASSERT(fs_pfh == nullptr);
#if WINDOWS
// open file on Windows
FILE* pfh = nullptr;
#ifndef SCRATCH_NO_UTF8
size_t sizeFileName = strlen(szFileName) + 1;
wchar_t* wszFileName = (wchar_t*)malloc(sizeof(wchar_t) * sizeFileName);
mbstowcs(wszFileName, szFileName, sizeFileName);
size_t sizeMode = strlen(szMode) + 1;
wchar_t* wszMode = (wchar_t*)malloc(sizeof(wchar_t) * sizeMode);
mbstowcs(wszMode, szMode, sizeMode);
#endif
if (sharedHandle) {
#ifdef SCRATCH_NO_UTF8
pfh = _fsopen(szFileName, szMode, _SH_DENYWR);
#else
pfh = _wfsopen(wszFileName, wszMode, _SH_DENYWR);
#endif
} else {
#ifdef SCRATCH_NO_UTF8
fopen_s(&pfh, szFileName, szMode);
#else
_wfopen_s(&pfh, wszFileName, wszMode);
#endif
}
#ifndef SCRATCH_NO_UTF8
free(wszFileName);
free(wszMode);
#endif
#else
// open file on linux
FILE* pfh = fopen(szFileName, szMode);
#endif
// it might not exist
if (pfh == nullptr) {
return false;
}
// remember info
fs_strFileName = szFileName;
fs_pfh = pfh;
// success
return true;
}
void dosyala(char *dosya_adi, char *alan)
{
FILE *fp;
if ((fp = _fsopen(dosya_adi, "rb+", SH_DENYNO)) == NULL) {
msj_kutu(NULL, "Disk kay�t hatas�", HATA);
exit(1);
}
fseek(fp, 0, SEEK_END);
fwrite(alan, 1, 4920, fp);
fclose(fp);
}
