diff options
Diffstat (limited to 'cpukit/shttpd/compat_wince.c')
| -rw-r--r-- | cpukit/shttpd/compat_wince.c | 1593 |
1 files changed, 1593 insertions, 0 deletions
diff --git a/cpukit/shttpd/compat_wince.c b/cpukit/shttpd/compat_wince.c new file mode 100644 index 0000000000..36702f6d4b --- /dev/null +++ b/cpukit/shttpd/compat_wince.c @@ -0,0 +1,1593 @@ +/* + vi:ts=8:sw=8:noet + * Copyright (c) 2006 Luke Dunstan <infidel@users.sourceforge.net> + * Partly based on code by David Kashtan, Validus Medical Systems + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +/* + * This file provides various functions that are available on desktop Windows + * but not on Windows CE + */ + +#ifdef _MSC_VER +/* Level 4 warnings caused by windows.h */ +#pragma warning(disable : 4214) // nonstandard extension used : bit field types other than int +#pragma warning(disable : 4115) // named type definition in parentheses +#pragma warning(disable : 4201) // nonstandard extension used : nameless struct/union +#pragma warning(disable : 4514) // unreferenced inline function has been removed +#pragma warning(disable : 4244) // conversion from 'int ' to 'unsigned short ', possible loss of data +#pragma warning(disable : 4100) // unreferenced formal parameter +#endif + +#include <windows.h> +#include <stdlib.h> + +#include "compat_wince.h" + + +static WCHAR *to_wide_string(LPCSTR pStr) +{ + int nwide; + WCHAR *buf; + + if(pStr == NULL) + return NULL; + nwide = MultiByteToWideChar(CP_ACP, 0, pStr, -1, NULL, 0); + if(nwide == 0) + return NULL; + buf = malloc(nwide * sizeof(WCHAR)); + if(buf == NULL) { + SetLastError(ERROR_NOT_ENOUGH_MEMORY); + return NULL; + } + if(MultiByteToWideChar(CP_ACP, 0, pStr, -1, buf, nwide) == 0) { + free(buf); + return NULL; + } + return buf; +} + +FILE *fdopen(int handle, const char *mode) +{ + WCHAR *wmode = to_wide_string(mode); + FILE *result; + + if(wmode != NULL) + result = _wfdopen((void *)handle, wmode); + else + result = NULL; + free(wmode); + return result; +} + +/* + * Time conversion constants + */ +#define FT_EPOCH (116444736000000000i64) +#define FT_TICKS (10000000i64) + + /* + * Convert a FILETIME to a time_t + */ +static time_t convert_FILETIME_to_time_t(FILETIME *File_Time) +{ + __int64 Temp; + + /* + * Convert the FILETIME structure to 100nSecs since 1601 (as a 64-bit value) + */ + Temp = (((__int64)File_Time->dwHighDateTime) << 32) + (__int64)File_Time->dwLowDateTime; + /* + * Convert to seconds from 1970 + */ + return((time_t)((Temp - FT_EPOCH) / FT_TICKS)); +} + +/* + * Convert a FILETIME to a tm structure + */ +static struct tm *Convert_FILETIME_To_tm(FILETIME *File_Time) +{ + SYSTEMTIME System_Time; + static struct tm tm = {0}; + static const short Day_Of_Year_By_Month[12] = {(short)(0), + (short)(31), + (short)(31 + 28), + (short)(31 + 28 + 31), + (short)(31 + 28 + 31 + 30), + (short)(31 + 28 + 31 + 30 + 31), + (short)(31 + 28 + 31 + 30 + 31 + 30), + (short)(31 + 28 + 31 + 30 + 31 + 30 + 31), + (short)(31 + 28 + 31 + 30 + 31 + 30 + 31 + 31), + (short)(31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30), + (short)(31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31), + (short)(31 + 28 + 31 + 30 + 31 + 30 + 31 + 31 + 30 + 31 + 30)}; + + + /* + * Turn the FILETIME into a SYSTEMTIME + */ + FileTimeToSystemTime(File_Time, &System_Time); + /* + * Use SYSTEMTIME to fill in the tm structure + */ + tm.tm_sec = System_Time.wSecond; + tm.tm_min = System_Time.wMinute; + tm.tm_hour = System_Time.wHour; + tm.tm_mday = System_Time.wDay; + tm.tm_mon = System_Time.wMonth - 1; + tm.tm_year = System_Time.wYear - 1900; + tm.tm_wday = System_Time.wDayOfWeek; + tm.tm_yday = Day_Of_Year_By_Month[tm.tm_mon] + tm.tm_mday - 1; + if (tm.tm_mon >= 2) { + /* + * Check for leap year (every 4 years but not every 100 years but every 400 years) + */ + if ((System_Time.wYear % 4) == 0) { + /* + * It Is a 4th year + */ + if ((System_Time.wYear % 100) == 0) { + /* + * It is a 100th year + */ + if ((System_Time.wYear % 400) == 0) { + /* + * It is a 400th year: It is a leap year + */ + tm.tm_yday++; + } + } else { + /* + * It is not a 100th year: It is a leap year + */ + tm.tm_yday++; + } + } + } + return(&tm); +} + +/* + * Convert a time_t to a FILETIME + */ +static void Convert_time_t_To_FILETIME(time_t Time, FILETIME *File_Time) +{ + __int64 Temp; + + /* + * Use 64-bit calculation to convert seconds since 1970 to + * 100nSecs since 1601 + */ + Temp = ((__int64)Time * FT_TICKS) + FT_EPOCH; + /* + * Put it into the FILETIME structure + */ + File_Time->dwLowDateTime = (DWORD)Temp; + File_Time->dwHighDateTime = (DWORD)(Temp >> 32); +} + +/* + * Convert a tm structure to a FILETIME + */ +static FILETIME *Convert_tm_To_FILETIME(struct tm *tm) +{ + SYSTEMTIME System_Time; + static FILETIME File_Time = {0}; + + /* + * Use the tm structure to fill in a SYSTEM + */ + System_Time.wYear = tm->tm_year + 1900; + System_Time.wMonth = tm->tm_mon + 1; + System_Time.wDayOfWeek = tm->tm_wday; + System_Time.wDay = tm->tm_mday; + System_Time.wHour = tm->tm_hour; + System_Time.wMinute = tm->tm_min; + System_Time.wSecond = tm->tm_sec; + System_Time.wMilliseconds = 0; + /* + * Convert it to a FILETIME and return it + */ + SystemTimeToFileTime(&System_Time, &File_Time); + return(&File_Time); +} + + +/************************************************************************/ +/* */ +/* Errno emulation: There is no errno on Windows/CE and we need */ +/* to make it per-thread. So we have a function */ +/* that returns a pointer to the errno for the */ +/* current thread. */ +/* */ +/* If there is ONLY the main thread then we can */ +/* quickly return some static storage. */ +/* */ +/* If we have multiple threads running, we use */ +/* Thread-Local Storage to hold the pointer */ +/* */ +/************************************************************************/ + +/* + * Function pointer for returning errno pointer + */ +static int *Initialize_Errno(void); +int *(*__WinCE_Errno_Pointer_Function)(void) = Initialize_Errno; + +/* + * Static errno storage for the main thread + */ +static int Errno_Storage = 0; + +/* + * Thread-Local storage slot for errno + */ +static int TLS_Errno_Slot = 0xffffffff; + +/* + * Number of threads we have running and critical section protection + * for manipulating it + */ +static int Number_Of_Threads = 0; +static CRITICAL_SECTION Number_Of_Threads_Critical_Section; + +/* + * For the main thread only -- return the errno pointer + */ +static int *Get_Main_Thread_Errno(void) +{ + return &Errno_Storage; +} + +/* + * When there is more than one thread -- return the errno pointer + */ +static int *Get_Thread_Errno(void) +{ + return (int *)TlsGetValue(TLS_Errno_Slot); +} + +/* + * Initialize a thread's errno + */ +static void Initialize_Thread_Errno(int *Errno_Pointer) +{ + /* + * Make sure we have a slot + */ + if (TLS_Errno_Slot == 0xffffffff) { + /* + * No: Get one + */ + TLS_Errno_Slot = (int)TlsAlloc(); + if (TLS_Errno_Slot == 0xffffffff) ExitProcess(3); + } + /* + * We can safely check for 0 threads, because + * only the main thread will be initializing + * at this point. Make sure the critical + * section that protects the number of threads + * is initialized + */ + if (Number_Of_Threads == 0) + InitializeCriticalSection(&Number_Of_Threads_Critical_Section); + /* + * Store the errno pointer + */ + if (TlsSetValue(TLS_Errno_Slot, (LPVOID)Errno_Pointer) == 0) ExitProcess(3); + /* + * Bump the number of threads + */ + EnterCriticalSection(&Number_Of_Threads_Critical_Section); + Number_Of_Threads++; + if (Number_Of_Threads > 1) { + /* + * We have threads other than the main thread: + * Use thread-local storage + */ + __WinCE_Errno_Pointer_Function = Get_Thread_Errno; + } + LeaveCriticalSection(&Number_Of_Threads_Critical_Section); +} + +/* + * Initialize errno emulation on Windows/CE (Main thread) + */ +static int *Initialize_Errno(void) +{ + /* + * Initialize the main thread's errno in thread-local storage + */ + Initialize_Thread_Errno(&Errno_Storage); + /* + * Set the errno function to be the one that returns the + * main thread's errno + */ + __WinCE_Errno_Pointer_Function = Get_Main_Thread_Errno; + /* + * Return the main thread's errno + */ + return &Errno_Storage; +} + +/* + * Initialize errno emulation on Windows/CE (New thread) + */ +void __WinCE_Errno_New_Thread(int *Errno_Pointer) +{ + Initialize_Thread_Errno(Errno_Pointer); +} + +/* + * Note that a thread has exited + */ +void __WinCE_Errno_Thread_Exit(void) +{ + /* + * Decrease the number of threads + */ + EnterCriticalSection(&Number_Of_Threads_Critical_Section); + Number_Of_Threads--; + if (Number_Of_Threads <= 1) { + /* + * We only have the main thread + */ + __WinCE_Errno_Pointer_Function = Get_Main_Thread_Errno; + } + LeaveCriticalSection(&Number_Of_Threads_Critical_Section); +} + + +char * +strerror(int errnum) +{ + return "(strerror not implemented)"; +} + +#define FT_EPOCH (116444736000000000i64) +#define FT_TICKS (10000000i64) + +int +_wstat(const WCHAR *path, struct _stat *buffer) +{ + WIN32_FIND_DATA data; + HANDLE handle; + WCHAR *p; + + /* Fail if wildcard characters are specified */ + if (wcscspn(path, L"?*") != wcslen(path)) + return -1; + + handle = FindFirstFile(path, &data); + if (handle == INVALID_HANDLE_VALUE) { + errno = GetLastError(); + return -1; + } + FindClose(handle); + + /* Found: Convert the file times */ + buffer->st_mtime = convert_FILETIME_to_time_t(&data.ftLastWriteTime); + if (data.ftLastAccessTime.dwLowDateTime || data.ftLastAccessTime.dwHighDateTime) + buffer->st_atime = convert_FILETIME_to_time_t(&data.ftLastAccessTime); + else + buffer->st_atime = buffer->st_mtime; + if (data.ftCreationTime.dwLowDateTime || data.ftCreationTime.dwHighDateTime) + buffer->st_ctime = convert_FILETIME_to_time_t(&data.ftCreationTime); + else + buffer->st_ctime = buffer->st_mtime; + + /* Convert the file modes */ + buffer->st_mode = (unsigned short)((data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? (S_IFDIR | S_IEXEC) : S_IFREG); + buffer->st_mode |= (data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? S_IREAD : (S_IREAD | S_IWRITE); + if((p = wcsrchr(path, L'.')) != NULL) { + p++; + if (_wcsicmp(p, L".exe") == 0) + buffer->st_mode |= S_IEXEC; + } + buffer->st_mode |= (buffer->st_mode & 0700) >> 3; + buffer->st_mode |= (buffer->st_mode & 0700) >> 6; + /* Set the other information */ + buffer->st_nlink = 1; + buffer->st_size = (unsigned long int)data.nFileSizeLow; + buffer->st_uid = 0; + buffer->st_gid = 0; + buffer->st_ino = 0 /*data.dwOID ?*/; + buffer->st_dev = 0; + + return 0; /* success */ +} + +/* + * Helper function for cemodule -- do an fstat() operation on a Win32 File Handle + */ +int +_fstat(int handle, struct _stat *st) +{ + BY_HANDLE_FILE_INFORMATION Data; + + /* + * Get the file information + */ + if (!GetFileInformationByHandle((HANDLE)handle, &Data)) { + /* + * Return error + */ + errno = GetLastError(); + return(-1); + } + /* + * Found: Convert the file times + */ + st->st_mtime=(time_t)((*(__int64*)&Data.ftLastWriteTime-FT_EPOCH)/FT_TICKS); + if(Data.ftLastAccessTime.dwLowDateTime || Data.ftLastAccessTime.dwHighDateTime) + st->st_atime=(time_t)((*(__int64*)&Data.ftLastAccessTime-FT_EPOCH)/FT_TICKS); + else + st->st_atime=st->st_mtime ; + if(Data.ftCreationTime.dwLowDateTime || Data.ftCreationTime.dwHighDateTime ) + st->st_ctime=(time_t)((*(__int64*)&Data.ftCreationTime-FT_EPOCH)/FT_TICKS); + else + st->st_ctime=st->st_mtime ; + /* + * Convert the file modes + */ + st->st_mode = (unsigned short)((Data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? (S_IFDIR | S_IEXEC) : S_IFREG); + st->st_mode |= (Data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? S_IREAD : (S_IREAD | S_IWRITE); + st->st_mode |= (st->st_mode & 0700) >> 3; + st->st_mode |= (st->st_mode & 0700) >> 6; + /* + * Set the other information + */ + st->st_nlink=1; + st->st_size=(unsigned long int)Data.nFileSizeLow; + st->st_uid=0; + st->st_gid=0; + st->st_ino=0; + st->st_dev=0; + /* + * Return success + */ + return(0); +} + +int _wopen(const wchar_t *filename, int oflag, ...) +{ + DWORD Access, ShareMode, CreationDisposition; + HANDLE Handle; + static int Modes[4] = {0, (GENERIC_READ | GENERIC_WRITE), GENERIC_READ, GENERIC_WRITE}; + + /* + * Calculate the CreateFile arguments + */ + Access = Modes[oflag & O_MODE_MASK]; + ShareMode = (oflag & O_EXCL) ? 0 : (FILE_SHARE_READ | FILE_SHARE_WRITE); + if (oflag & O_TRUNC) + CreationDisposition = (oflag & O_CREAT) ? CREATE_ALWAYS : TRUNCATE_EXISTING; + else + CreationDisposition = (oflag & O_CREAT) ? CREATE_NEW : OPEN_EXISTING; + + Handle = CreateFileW(filename, Access, ShareMode, NULL, CreationDisposition, FILE_ATTRIBUTE_NORMAL, NULL); + + /* + * Deal with errors + */ + if (Handle == INVALID_HANDLE_VALUE) { + errno = GetLastError(); + if ((errno == ERROR_ALREADY_EXISTS) || (errno == ERROR_FILE_EXISTS)) + errno = ERROR_ALREADY_EXISTS; + return -1; + } + /* + * Return the handle + */ + return (int)Handle; +} + +int +_close(int handle) +{ + if(CloseHandle((HANDLE)handle)) + return 0; + errno = GetLastError(); + return -1; +} + +int +_write(int handle, const void *buffer, unsigned int count) +{ + DWORD numwritten = 0; + if(!WriteFile((HANDLE)handle, buffer, count, &numwritten, NULL)) { + errno = GetLastError(); + return -1; + } + return numwritten; +} + +int +_read(int handle, void *buffer, unsigned int count) +{ + DWORD numread = 0; + if(!ReadFile((HANDLE)handle, buffer, count, &numread, NULL)) { + errno = GetLastError(); + return -1; + } + return numread; +} + +long +_lseek(int handle, long offset, int origin) +{ + DWORD dwMoveMethod; + DWORD result; + + switch(origin) { + default: + errno = EINVAL; + return -1L; + case SEEK_SET: + dwMoveMethod = FILE_BEGIN; + break; + case SEEK_CUR: + dwMoveMethod = FILE_CURRENT; + break; + case SEEK_END: + dwMoveMethod = FILE_END; + break; + } + result = SetFilePointer((HANDLE)handle, offset, NULL, dwMoveMethod); + if(result == 0xFFFFFFFF) { + errno = GetLastError(); + return -1; + } + return (long)result; +} + +int +_wmkdir(const wchar_t *dirname) +{ + if(!CreateDirectoryW(dirname, NULL)) { + errno = GetLastError(); + return -1; + } + return 0; +} + +int +_wremove(const wchar_t *filename) +{ + if(!DeleteFileW(filename)) { + errno = GetLastError(); + return -1; + } + return 0; +} + +int +_wrename(const wchar_t *oldname, const wchar_t *newname) +{ + if(!MoveFileW(oldname, newname)) { + errno = GetLastError(); + return -1; + } + return 0; +} + +wchar_t * +_wgetcwd(wchar_t *buffer, int maxlen) +{ + wchar_t *result; + WCHAR wszPath[MAX_PATH + 1]; + WCHAR *p; + + if(!GetModuleFileNameW(NULL, wszPath, MAX_PATH + 1)) { + errno = GetLastError(); + return NULL; + } + /* Remove the filename part of the path to leave the directory */ + p = wcsrchr(wszPath, L'\\'); + if(p) + *p = L'\0'; + + if(buffer == NULL) + result = _wcsdup(wszPath); + else if(wcslen(wszPath) + 1 > (size_t)maxlen) { + result = NULL; + errno = ERROR_INSUFFICIENT_BUFFER; + } else { + wcsncpy(buffer, wszPath, maxlen); + buffer[maxlen - 1] = L'\0'; + result = buffer; + } + return result; +} + +/* + * The missing "C" runtime gmtime() function + */ +struct tm *gmtime(const time_t *TimeP) +{ + FILETIME File_Time; + + /* + * Deal with null time pointer + */ + if (!TimeP) return(NULL); + /* + * time_t -> FILETIME -> tm + */ + Convert_time_t_To_FILETIME(*TimeP, &File_Time); + return(Convert_FILETIME_To_tm(&File_Time)); +} + +/* + * The missing "C" runtime localtime() function + */ +struct tm *localtime(const time_t *TimeP) +{ + FILETIME File_Time, Local_File_Time; + + /* + * Deal with null time pointer + */ + if (!TimeP) return(NULL); + /* + * time_t -> FILETIME -> Local FILETIME -> tm + */ + Convert_time_t_To_FILETIME(*TimeP, &File_Time); + FileTimeToLocalFileTime(&File_Time, &Local_File_Time); + return(Convert_FILETIME_To_tm(&Local_File_Time)); +} + +/* + * The missing "C" runtime mktime() function + */ +time_t mktime(struct tm *tm) +{ + FILETIME *Local_File_Time; + FILETIME File_Time; + + /* + * tm -> Local FILETIME -> FILETIME -> time_t + */ + Local_File_Time = Convert_tm_To_FILETIME(tm); + LocalFileTimeToFileTime(Local_File_Time, &File_Time); + return(convert_FILETIME_to_time_t(&File_Time)); +} + +/* + * Missing "C" runtime time() function + */ +time_t time(time_t *TimeP) +{ + SYSTEMTIME System_Time; + FILETIME File_Time; + time_t Result; + + /* + * Get the current system time + */ + GetSystemTime(&System_Time); + /* + * SYSTEMTIME -> FILETIME -> time_t + */ + SystemTimeToFileTime(&System_Time, &File_Time); + Result = convert_FILETIME_to_time_t(&File_Time); + /* + * Return the time_t + */ + if (TimeP) *TimeP = Result; + return(Result); +} + +static char Standard_Name[32] = "GMT"; +static char Daylight_Name[32] = "GMT"; +char *tzname[2] = {Standard_Name, Daylight_Name}; +long timezone = 0; +int daylight = 0; + +void tzset(void) +{ + TIME_ZONE_INFORMATION Info; + int Result; + + /* + * Get our current timezone information + */ + Result = GetTimeZoneInformation(&Info); + switch(Result) { + /* + * We are on standard time + */ + case TIME_ZONE_ID_STANDARD: + daylight = 0; + break; + /* + * We are on daylight savings time + */ + case TIME_ZONE_ID_DAYLIGHT: + daylight = 1; + break; + /* + * We don't know the timezone information (leave it GMT) + */ + default: return; + } + /* + * Extract the timezone information + */ + timezone = Info.Bias * 60; + if (Info.StandardName[0]) + WideCharToMultiByte(CP_ACP, 0, Info.StandardName, -1, Standard_Name, sizeof(Standard_Name) - 1, NULL, NULL); + if (Info.DaylightName[0]) + WideCharToMultiByte(CP_ACP, 0, Info.DaylightName, -1, Daylight_Name, sizeof(Daylight_Name) - 1, NULL, NULL); +} + +/*** strftime() from newlib libc/time/strftime.c ***/ + +/* + * Sane snprintf(). Acts like snprintf(), but never return -1 or the + * value bigger than supplied buffer. + */ +static int +Snprintf(char *buf, size_t buflen, const char *fmt, ...) +{ + va_list ap; + int n; + + if (buflen == 0) + return (0); + + va_start(ap, fmt); + n = _vsnprintf(buf, buflen, fmt, ap); + va_end(ap); + + if (n < 0 || n > (int) buflen - 1) { + n = buflen - 1; + } + buf[n] = '\0'; + + return (n); +} + +#define snprintf Snprintf + +/* from libc/include/_ansi.h */ +#define _CONST const +#define _DEFUN(name, arglist, args) name(args) +#define _AND , +/* from libc/time/local.h */ +#define TZ_LOCK +#define TZ_UNLOCK +#define _tzname tzname +#define isleap(y) ((((y) % 4) == 0 && ((y) % 100) != 0) || ((y) % 400) == 0) +#define YEAR_BASE 1900 +#define SECSPERMIN 60L +#define MINSPERHOUR 60L +#define HOURSPERDAY 24L +#define SECSPERHOUR (SECSPERMIN * MINSPERHOUR) + +/* + * strftime.c + * Original Author: G. Haley + * Additions from: Eric Blake + * + * Places characters into the array pointed to by s as controlled by the string + * pointed to by format. If the total number of resulting characters including + * the terminating null character is not more than maxsize, returns the number + * of characters placed into the array pointed to by s (not including the + * terminating null character); otherwise zero is returned and the contents of + * the array indeterminate. + */ + +/* +FUNCTION +<<strftime>>---flexible calendar time formatter + +INDEX + strftime + +ANSI_SYNOPSIS + #include <time.h> + size_t strftime(char *<[s]>, size_t <[maxsize]>, + const char *<[format]>, const struct tm *<[timp]>); + +TRAD_SYNOPSIS + #include <time.h> + size_t strftime(<[s]>, <[maxsize]>, <[format]>, <[timp]>) + char *<[s]>; + size_t <[maxsize]>; + char *<[format]>; + struct tm *<[timp]>; + +DESCRIPTION +<<strftime>> converts a <<struct tm>> representation of the time (at +<[timp]>) into a null-terminated string, starting at <[s]> and occupying +no more than <[maxsize]> characters. + +You control the format of the output using the string at <[format]>. +<<*<[format]>>> can contain two kinds of specifications: text to be +copied literally into the formatted string, and time conversion +specifications. Time conversion specifications are two- and +three-character sequences beginning with `<<%>>' (use `<<%%>>' to +include a percent sign in the output). Each defined conversion +specification selects only the specified field(s) of calendar time +data from <<*<[timp]>>>, and converts it to a string in one of the +following ways: + +o+ +o %a +A three-letter abbreviation for the day of the week. [tm_wday] + +o %A +The full name for the day of the week, one of `<<Sunday>>', +`<<Monday>>', `<<Tuesday>>', `<<Wednesday>>', `<<Thursday>>', +`<<Friday>>', or `<<Saturday>>'. [tm_wday] + +o %b +A three-letter abbreviation for the month name. [tm_mon] + +o %B +The full name of the month, one of `<<January>>', `<<February>>', +`<<March>>', `<<April>>', `<<May>>', `<<June>>', `<<July>>', +`<<August>>', `<<September>>', `<<October>>', `<<November>>', +`<<December>>'. [tm_mon] + +o %c +A string representing the complete date and time, in the form +`<<"%a %b %e %H:%M:%S %Y">>' (example "Mon Apr 01 13:13:13 +1992"). [tm_sec, tm_min, tm_hour, tm_mday, tm_mon, tm_year, tm_wday] + +o %C +The century, that is, the year divided by 100 then truncated. For +4-digit years, the result is zero-padded and exactly two characters; +but for other years, there may a negative sign or more digits. In +this way, `<<%C%y>>' is equivalent to `<<%Y>>'. [tm_year] + +o %d +The day of the month, formatted with two digits (from `<<01>>' to +`<<31>>'). [tm_mday] + +o %D +A string representing the date, in the form `<<"%m/%d/%y">>'. +[tm_mday, tm_mon, tm_year] + +o %e +The day of the month, formatted with leading space if single digit +(from `<<1>>' to `<<31>>'). [tm_mday] + +o %E<<x>> +In some locales, the E modifier selects alternative representations of +certain modifiers <<x>>. But in the "C" locale supported by newlib, +it is ignored, and treated as %<<x>>. + +o %F +A string representing the ISO 8601:2000 date format, in the form +`<<"%Y-%m-%d">>'. [tm_mday, tm_mon, tm_year] + +o %g +The last two digits of the week-based year, see specifier %G (from +`<<00>>' to `<<99>>'). [tm_year, tm_wday, tm_yday] + +o %G +The week-based year. In the ISO 8601:2000 calendar, week 1 of the year +includes January 4th, and begin on Mondays. Therefore, if January 1st, +2nd, or 3rd falls on a Sunday, that day and earlier belong to the last +week of the previous year; and if December 29th, 30th, or 31st falls +on Monday, that day and later belong to week 1 of the next year. For +consistency with %Y, it always has at least four characters. +Example: "%G" for Saturday 2nd January 1999 gives "1998", and for +Tuesday 30th December 1997 gives "1998". [tm_year, tm_wday, tm_yday] + +o %h +A three-letter abbreviation for the month name (synonym for +"%b"). [tm_mon] + +o %H +The hour (on a 24-hour clock), formatted with two digits (from +`<<00>>' to `<<23>>'). [tm_hour] + +o %I +The hour (on a 12-hour clock), formatted with two digits (from +`<<01>>' to `<<12>>'). [tm_hour] + +o %j +The count of days in the year, formatted with three digits +(from `<<001>>' to `<<366>>'). [tm_yday] + +o %k +The hour (on a 24-hour clock), formatted with leading space if single +digit (from `<<0>>' to `<<23>>'). Non-POSIX extension. [tm_hour] + +o %l +The hour (on a 12-hour clock), formatted with leading space if single +digit (from `<<1>>' to `<<12>>'). Non-POSIX extension. [tm_hour] + +o %m +The month number, formatted with two digits (from `<<01>>' to `<<12>>'). +[tm_mon] + +o %M +The minute, formatted with two digits (from `<<00>>' to `<<59>>'). [tm_min] + +o %n +A newline character (`<<\n>>'). + +o %O<<x>> +In some locales, the O modifier selects alternative digit characters +for certain modifiers <<x>>. But in the "C" locale supported by newlib, it +is ignored, and treated as %<<x>>. + +o %p +Either `<<AM>>' or `<<PM>>' as appropriate. [tm_hour] + +o %r +The 12-hour time, to the second. Equivalent to "%I:%M:%S %p". [tm_sec, +tm_min, tm_hour] + +o %R +The 24-hour time, to the minute. Equivalent to "%H:%M". [tm_min, tm_hour] + +o %S +The second, formatted with two digits (from `<<00>>' to `<<60>>'). The +value 60 accounts for the occasional leap second. [tm_sec] + +o %t +A tab character (`<<\t>>'). + +o %T +The 24-hour time, to the second. Equivalent to "%H:%M:%S". [tm_sec, +tm_min, tm_hour] + +o %u +The weekday as a number, 1-based from Monday (from `<<1>>' to +`<<7>>'). [tm_wday] + +o %U +The week number, where weeks start on Sunday, week 1 contains the first +Sunday in a year, and earlier days are in week 0. Formatted with two +digits (from `<<00>>' to `<<53>>'). See also <<%W>>. [tm_wday, tm_yday] + +o %V +The week number, where weeks start on Monday, week 1 contains January 4th, +and earlier days are in the previous year. Formatted with two digits +(from `<<01>>' to `<<53>>'). See also <<%G>>. [tm_year, tm_wday, tm_yday] + +o %w +The weekday as a number, 0-based from Sunday (from `<<0>>' to `<<6>>'). +[tm_wday] + +o %W +The week number, where weeks start on Monday, week 1 contains the first +Monday in a year, and earlier days are in week 0. Formatted with two +digits (from `<<00>>' to `<<53>>'). [tm_wday, tm_yday] + +o %x +A string representing the complete date, equivalent to "%m/%d/%y". +[tm_mon, tm_mday, tm_year] + +o %X +A string representing the full time of day (hours, minutes, and +seconds), equivalent to "%H:%M:%S". [tm_sec, tm_min, tm_hour] + +o %y +The last two digits of the year (from `<<00>>' to `<<99>>'). [tm_year] + +o %Y +The full year, equivalent to <<%C%y>>. It will always have at least four +characters, but may have more. The year is accurate even when tm_year +added to the offset of 1900 overflows an int. [tm_year] + +o %z +The offset from UTC. The format consists of a sign (negative is west of +Greewich), two characters for hour, then two characters for minutes +(-hhmm or +hhmm). If tm_isdst is negative, the offset is unknown and no +output is generated; if it is zero, the offset is the standard offset for +the current time zone; and if it is positive, the offset is the daylight +savings offset for the current timezone. The offset is determined from +the TZ environment variable, as if by calling tzset(). [tm_isdst] + +o %Z +The time zone name. If tm_isdst is negative, no output is generated. +Otherwise, the time zone name is based on the TZ environment variable, +as if by calling tzset(). [tm_isdst] + +o %% +A single character, `<<%>>'. +o- + +RETURNS +When the formatted time takes up no more than <[maxsize]> characters, +the result is the length of the formatted string. Otherwise, if the +formatting operation was abandoned due to lack of room, the result is +<<0>>, and the string starting at <[s]> corresponds to just those +parts of <<*<[format]>>> that could be completely filled in within the +<[maxsize]> limit. + +PORTABILITY +ANSI C requires <<strftime>>, but does not specify the contents of +<<*<[s]>>> when the formatted string would require more than +<[maxsize]> characters. Unrecognized specifiers and fields of +<<timp>> that are out of range cause undefined results. Since some +formats expand to 0 bytes, it is wise to set <<*<[s]>>> to a nonzero +value beforehand to distinguish between failure and an empty string. +This implementation does not support <<s>> being NULL, nor overlapping +<<s>> and <<format>>. + +<<strftime>> requires no supporting OS subroutines. +*/ + +static _CONST int dname_len[7] = +{6, 6, 7, 9, 8, 6, 8}; + +static _CONST char *_CONST dname[7] = +{"Sunday", "Monday", "Tuesday", "Wednesday", + "Thursday", "Friday", "Saturday"}; + +static _CONST int mname_len[12] = +{7, 8, 5, 5, 3, 4, 4, 6, 9, 7, 8, 8}; + +static _CONST char *_CONST mname[12] = +{"January", "February", "March", "April", + "May", "June", "July", "August", "September", "October", "November", + "December"}; + +/* Using the tm_year, tm_wday, and tm_yday components of TIM_P, return + -1, 0, or 1 as the adjustment to add to the year for the ISO week + numbering used in "%g%G%V", avoiding overflow. */ +static int +_DEFUN (iso_year_adjust, (tim_p), + _CONST struct tm *tim_p) +{ + /* Account for fact that tm_year==0 is year 1900. */ + int leap = isleap (tim_p->tm_year + (YEAR_BASE + - (tim_p->tm_year < 0 ? 0 : 2000))); + + /* Pack the yday, wday, and leap year into a single int since there are so + many disparate cases. */ +#define PACK(yd, wd, lp) (((yd) << 4) + (wd << 1) + (lp)) + switch (PACK (tim_p->tm_yday, tim_p->tm_wday, leap)) + { + case PACK (0, 5, 0): /* Jan 1 is Fri, not leap. */ + case PACK (0, 6, 0): /* Jan 1 is Sat, not leap. */ + case PACK (0, 0, 0): /* Jan 1 is Sun, not leap. */ + case PACK (0, 5, 1): /* Jan 1 is Fri, leap year. */ + case PACK (0, 6, 1): /* Jan 1 is Sat, leap year. */ + case PACK (0, 0, 1): /* Jan 1 is Sun, leap year. */ + case PACK (1, 6, 0): /* Jan 2 is Sat, not leap. */ + case PACK (1, 0, 0): /* Jan 2 is Sun, not leap. */ + case PACK (1, 6, 1): /* Jan 2 is Sat, leap year. */ + case PACK (1, 0, 1): /* Jan 2 is Sun, leap year. */ + case PACK (2, 0, 0): /* Jan 3 is Sun, not leap. */ + case PACK (2, 0, 1): /* Jan 3 is Sun, leap year. */ + return -1; /* Belongs to last week of previous year. */ + case PACK (362, 1, 0): /* Dec 29 is Mon, not leap. */ + case PACK (363, 1, 1): /* Dec 29 is Mon, leap year. */ + case PACK (363, 1, 0): /* Dec 30 is Mon, not leap. */ + case PACK (363, 2, 0): /* Dec 30 is Tue, not leap. */ + case PACK (364, 1, 1): /* Dec 30 is Mon, leap year. */ + case PACK (364, 2, 1): /* Dec 30 is Tue, leap year. */ + case PACK (364, 1, 0): /* Dec 31 is Mon, not leap. */ + case PACK (364, 2, 0): /* Dec 31 is Tue, not leap. */ + case PACK (364, 3, 0): /* Dec 31 is Wed, not leap. */ + case PACK (365, 1, 1): /* Dec 31 is Mon, leap year. */ + case PACK (365, 2, 1): /* Dec 31 is Tue, leap year. */ + case PACK (365, 3, 1): /* Dec 31 is Wed, leap year. */ + return 1; /* Belongs to first week of next year. */ + } + return 0; /* Belongs to specified year. */ +#undef PACK +} + +size_t +_DEFUN (strftime, (s, maxsize, format, tim_p), + char *s _AND + size_t maxsize _AND + _CONST char *format _AND + _CONST struct tm *tim_p) +{ + size_t count = 0; + int i; + + for (;;) + { + while (*format && *format != '%') + { + if (count < maxsize - 1) + s[count++] = *format++; + else + return 0; + } + + if (*format == '\0') + break; + + format++; + if (*format == 'E' || *format == 'O') + format++; + + switch (*format) + { + case 'a': + for (i = 0; i < 3; i++) + { + if (count < maxsize - 1) + s[count++] = + dname[tim_p->tm_wday][i]; + else + return 0; + } + break; + case 'A': + for (i = 0; i < dname_len[tim_p->tm_wday]; i++) + { + if (count < maxsize - 1) + s[count++] = + dname[tim_p->tm_wday][i]; + else + return 0; + } + break; + case 'b': + case 'h': + for (i = 0; i < 3; i++) + { + if (count < maxsize - 1) + s[count++] = + mname[tim_p->tm_mon][i]; + else + return 0; + } + break; + case 'B': + for (i = 0; i < mname_len[tim_p->tm_mon]; i++) + { + if (count < maxsize - 1) + s[count++] = + mname[tim_p->tm_mon][i]; + else + return 0; + } + break; + case 'c': + { + /* Length is not known because of %C%y, so recurse. */ + size_t adjust = strftime (&s[count], maxsize - count, + "%a %b %e %H:%M:%S %C%y", tim_p); + if (adjust > 0) + count += adjust; + else + return 0; + } + break; + case 'C': + { + /* Examples of (tm_year + YEAR_BASE) that show how %Y == %C%y + with 32-bit int. + %Y %C %y + 2147485547 21474855 47 + 10000 100 00 + 9999 99 99 + 0999 09 99 + 0099 00 99 + 0001 00 01 + 0000 00 00 + -001 -0 01 + -099 -0 99 + -999 -9 99 + -1000 -10 00 + -10000 -100 00 + -2147481748 -21474817 48 + + Be careful of both overflow and sign adjustment due to the + asymmetric range of years. + */ + int neg = tim_p->tm_year < -YEAR_BASE; + int century = tim_p->tm_year >= 0 + ? tim_p->tm_year / 100 + YEAR_BASE / 100 + : abs (tim_p->tm_year + YEAR_BASE) / 100; + count += snprintf (&s[count], maxsize - count, "%s%.*d", + neg ? "-" : "", 2 - neg, century); + if (count >= maxsize) + return 0; + } + break; + case 'd': + case 'e': + if (count < maxsize - 2) + { + sprintf (&s[count], *format == 'd' ? "%.2d" : "%2d", + tim_p->tm_mday); + count += 2; + } + else + return 0; + break; + case 'D': + case 'x': + /* %m/%d/%y */ + if (count < maxsize - 8) + { + sprintf (&s[count], "%.2d/%.2d/%.2d", + tim_p->tm_mon + 1, tim_p->tm_mday, + tim_p->tm_year >= 0 ? tim_p->tm_year % 100 + : abs (tim_p->tm_year + YEAR_BASE) % 100); + count += 8; + } + else + return 0; + break; + case 'F': + { + /* Length is not known because of %C%y, so recurse. */ + size_t adjust = strftime (&s[count], maxsize - count, + "%C%y-%m-%d", tim_p); + if (adjust > 0) + count += adjust; + else + return 0; + } + break; + case 'g': + if (count < maxsize - 2) + { + /* Be careful of both overflow and negative years, thanks to + the asymmetric range of years. */ + int adjust = iso_year_adjust (tim_p); + int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100 + : abs (tim_p->tm_year + YEAR_BASE) % 100; + if (adjust < 0 && tim_p->tm_year <= -YEAR_BASE) + adjust = 1; + else if (adjust > 0 && tim_p->tm_year < -YEAR_BASE) + adjust = -1; + sprintf (&s[count], "%.2d", + ((year + adjust) % 100 + 100) % 100); + count += 2; + } + else + return 0; + break; + case 'G': + { + /* See the comments for 'C' and 'Y'; this is a variable length + field. Although there is no requirement for a minimum number + of digits, we use 4 for consistency with 'Y'. */ + int neg = tim_p->tm_year < -YEAR_BASE; + int adjust = iso_year_adjust (tim_p); + int century = tim_p->tm_year >= 0 + ? tim_p->tm_year / 100 + YEAR_BASE / 100 + : abs (tim_p->tm_year + YEAR_BASE) / 100; + int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100 + : abs (tim_p->tm_year + YEAR_BASE) % 100; + if (adjust < 0 && tim_p->tm_year <= -YEAR_BASE) + neg = adjust = 1; + else if (adjust > 0 && neg) + adjust = -1; + year += adjust; + if (year == -1) + { + year = 99; + --century; + } + else if (year == 100) + { + year = 0; + ++century; + } + count += snprintf (&s[count], maxsize - count, "%s%.*d%.2d", + neg ? "-" : "", 2 - neg, century, year); + if (count >= maxsize) + return 0; + } + break; + case 'H': + case 'k': + if (count < maxsize - 2) + { + sprintf (&s[count], *format == 'k' ? "%2d" : "%.2d", + tim_p->tm_hour); + count += 2; + } + else + return 0; + break; + case 'I': + case 'l': + if (count < maxsize - 2) + { + if (tim_p->tm_hour == 0 || + tim_p->tm_hour == 12) + { + s[count++] = '1'; + s[count++] = '2'; + } + else + { + sprintf (&s[count], *format == 'I' ? "%.2d" : "%2d", + tim_p->tm_hour % 12); + count += 2; + } + } + else + return 0; + break; + case 'j': + if (count < maxsize - 3) + { + sprintf (&s[count], "%.3d", + tim_p->tm_yday + 1); + count += 3; + } + else + return 0; + break; + case 'm': + if (count < maxsize - 2) + { + sprintf (&s[count], "%.2d", + tim_p->tm_mon + 1); + count += 2; + } + else + return 0; + break; + case 'M': + if (count < maxsize - 2) + { + sprintf (&s[count], "%.2d", + tim_p->tm_min); + count += 2; + } + else + return 0; + break; + case 'n': + if (count < maxsize - 1) + s[count++] = '\n'; + else + return 0; + break; + case 'p': + if (count < maxsize - 2) + { + if (tim_p->tm_hour < 12) + s[count++] = 'A'; + else + s[count++] = 'P'; + + s[count++] = 'M'; + } + else + return 0; + break; + case 'r': + if (count < maxsize - 11) + { + if (tim_p->tm_hour == 0 || + tim_p->tm_hour == 12) + { + s[count++] = '1'; + s[count++] = '2'; + } + else + { + sprintf (&s[count], "%.2d", tim_p->tm_hour % 12); + count += 2; + } + s[count++] = ':'; + sprintf (&s[count], "%.2d", + tim_p->tm_min); + count += 2; + s[count++] = ':'; + sprintf (&s[count], "%.2d", + tim_p->tm_sec); + count += 2; + s[count++] = ' '; + if (tim_p->tm_hour < 12) + s[count++] = 'A'; + else + s[count++] = 'P'; + + s[count++] = 'M'; + } + else + return 0; + break; + case 'R': + if (count < maxsize - 5) + { + sprintf (&s[count], "%.2d:%.2d", tim_p->tm_hour, tim_p->tm_min); + count += 5; + } + else + return 0; + break; + case 'S': + if (count < maxsize - 2) + { + sprintf (&s[count], "%.2d", + tim_p->tm_sec); + count += 2; + } + else + return 0; + break; + case 't': + if (count < maxsize - 1) + s[count++] = '\t'; + else + return 0; + break; + case 'T': + case 'X': + if (count < maxsize - 8) + { + sprintf (&s[count], "%.2d:%.2d:%.2d", tim_p->tm_hour, + tim_p->tm_min, tim_p->tm_sec); + count += 8; + } + else + return 0; + break; + case 'u': + if (count < maxsize - 1) + { + if (tim_p->tm_wday == 0) + s[count++] = '7'; + else + s[count++] = '0' + tim_p->tm_wday; + } + else + return 0; + break; + case 'U': + if (count < maxsize - 2) + { + sprintf (&s[count], "%.2d", + (tim_p->tm_yday + 7 - + tim_p->tm_wday) / 7); + count += 2; + } + else + return 0; + break; + case 'V': + if (count < maxsize - 2) + { + int adjust = iso_year_adjust (tim_p); + int wday = (tim_p->tm_wday) ? tim_p->tm_wday - 1 : 6; + int week = (tim_p->tm_yday + 10 - wday) / 7; + if (adjust > 0) + week = 1; + else if (adjust < 0) + /* Previous year has 53 weeks if current year starts on + Fri, and also if current year starts on Sat and + previous year was leap year. */ + week = 52 + (4 >= (wday - tim_p->tm_yday + - isleap (tim_p->tm_year + + (YEAR_BASE - 1 + - (tim_p->tm_year < 0 + ? 0 : 2000))))); + sprintf (&s[count], "%.2d", week); + count += 2; + } + else + return 0; + break; + case 'w': + if (count < maxsize - 1) + s[count++] = '0' + tim_p->tm_wday; + else + return 0; + break; + case 'W': + if (count < maxsize - 2) + { + int wday = (tim_p->tm_wday) ? tim_p->tm_wday - 1 : 6; + sprintf (&s[count], "%.2d", + (tim_p->tm_yday + 7 - wday) / 7); + count += 2; + } + else + return 0; + break; + case 'y': + if (count < maxsize - 2) + { + /* Be careful of both overflow and negative years, thanks to + the asymmetric range of years. */ + int year = tim_p->tm_year >= 0 ? tim_p->tm_year % 100 + : abs (tim_p->tm_year + YEAR_BASE) % 100; + sprintf (&s[count], "%.2d", year); + count += 2; + } + else + return 0; + break; + case 'Y': + { + /* Length is not known because of %C%y, so recurse. */ + size_t adjust = strftime (&s[count], maxsize - count, + "%C%y", tim_p); + if (adjust > 0) + count += adjust; + else + return 0; + } + break; + case 'z': +#ifndef _WIN32_WCE + if (tim_p->tm_isdst >= 0) + { + if (count < maxsize - 5) + { + long offset; + __tzinfo_type *tz = __gettzinfo (); + TZ_LOCK; + /* The sign of this is exactly opposite the envvar TZ. We + could directly use the global _timezone for tm_isdst==0, + but have to use __tzrule for daylight savings. */ + offset = -tz->__tzrule[tim_p->tm_isdst > 0].offset; + TZ_UNLOCK; + sprintf (&s[count], "%+03ld%.2ld", offset / SECSPERHOUR, + labs (offset / SECSPERMIN) % 60L); + count += 5; + } + else + return 0; + } + break; +#endif + case 'Z': + if (tim_p->tm_isdst >= 0) + { + int size; + TZ_LOCK; + size = strlen(_tzname[tim_p->tm_isdst > 0]); + for (i = 0; i < size; i++) + { + if (count < maxsize - 1) + s[count++] = _tzname[tim_p->tm_isdst > 0][i]; + else + { + TZ_UNLOCK; + return 0; + } + } + TZ_UNLOCK; + } + break; + case '%': + if (count < maxsize - 1) + s[count++] = '%'; + else + return 0; + break; + } + if (*format) + format++; + else + break; + } + if (maxsize) + s[count] = '\0'; + + return count; +} |