void RasterTerrain::OpenTerrain(void)
{
TCHAR szFile[MAX_PATH] = TEXT("\0");
GetRegistryString(szRegistryTerrainFile, szFile, MAX_PATH);
char zfilename[MAX_PATH];
ExpandLocalPath(szFile);
unicode2ascii(szFile, zfilename, MAX_PATH);
if (strlen(zfilename)==0) {
static TCHAR szMapFile[MAX_PATH] = TEXT("\0");
GetRegistryString(szRegistryMapFile, szMapFile, MAX_PATH);
ExpandLocalPath(szMapFile);
_tcscpy(szFile,szMapFile);
_tcscat(szFile,TEXT("/terrain.jp2"));
unicode2ascii(szFile, zfilename, MAX_PATH);
}
// TODO code: Check locking, especially when reloading a file.
// TODO bug: Fix cache method
CreateTerrainMap(zfilename);
}
// Get the user id from Leonardo servername
// returns 0=no id, -1=transaction failed
static int GetUserIDFromServer()
{
int retval = -1;
int rxlen;
char txbuf[512];
char username[128];
char password[128];
char rxcontent[32];
unicode2ascii(LiveTrackerusr_Config, txbuf, sizeof(username));
UrlEncode(txbuf, username, sizeof(username));
unicode2ascii(LiveTrackerpwd_Config, txbuf, sizeof(password));
UrlEncode(txbuf, password, sizeof(username));
sprintf(txbuf,"GET /client.php?op=login&user=%s&pass=%s HTTP/1.0\r\nHost: %s\r\n\r\n",
username, password,
_server_name);
rxlen = DoTransactionToServer(txbuf, strlen(txbuf), rxcontent, sizeof(rxcontent));
if ( rxlen > 0) {
rxcontent[rxlen]=0;
retval = -1;
sscanf(rxcontent,"%d",&retval);
}
return retval;
}
/* ARGSUSED */
static void
output_trans2_findfirst(int flags, uchar_t *data, char *xtra, int xsz)
{
int length;
char filename[256];
char infolevel[100];
if (flags & F_SUM) {
length = snprintf(xtra, xsz, " Findfirst");
xtra += length;
xsz -= length;
data += 12;
(void) unicode2ascii(filename, 256, data, 512);
snprintf(xtra, xsz, " File=%s", filename);
}
if (flags & F_DTAIL) {
show_line("FunctionName = Findfirst");
show_printf("SearchAttributes = 0x%.4x", get2(data));
data += 2;
show_printf("FindCount = 0x%.4x", get2(data));
data += 2;
show_printf("FindFlags = 0x%.4x", get2(data));
data += 2;
get_info_level(infolevel, sizeof (infolevel), get2(data));
show_printf("InfoLevel = %s", infolevel);
data += 6;
(void) unicode2ascii(filename, 256, data, 512);
show_printf("FileName = %s", filename);
}
}
FILE* _wfopen(const wchar_t* filename, const wchar_t* mode)
{
char filenameA[1024];
char modeA[10];
unicode2ascii(filename, filenameA, 1024);
unicode2ascii(mode, modeA, 10);
return fopen(filenameA, modeA);
}
void
ReadAirspace(AirspaceDatabase &airspace_database, RasterTerrain *terrain)
{
TCHAR tpath[MAX_PATH];
// TODO bug: add exception handler to protect parser code against chrashes
// TODO bug: second file should be opened even if first was not okay
// Read the airspace filenames from the registry
GetRegistryString(szRegistryAirspaceFile, tpath, MAX_PATH);
if (tpath[0] != 0) {
ExpandLocalPath(tpath);
char path[MAX_PATH];
unicode2ascii(tpath, path, sizeof(path));
if (!ReadAirspace(airspace_database, path))
StartupStore(TEXT("No airspace file 1\n"));
} else {
// TODO feature: airspace in xcm files should be a feature
/*
static TCHAR szMapFile[MAX_PATH] = TEXT("\0");
GetRegistryString(szRegistryMapFile, szMapFile, MAX_PATH);
ExpandLocalPath(szMapFile);
wcscat(szMapFile,TEXT("/"));
wcscat(szMapFile,TEXT("airspace.txt"));
unicode2ascii(szMapFile, zfilename, MAX_PATH);
fp = zzip_fopen(zfilename, "rt");
*/
}
GetRegistryString(szRegistryAdditionalAirspaceFile, tpath, MAX_PATH);
if (tpath[0] != 0) {
ExpandLocalPath(tpath);
char path[MAX_PATH];
unicode2ascii(tpath, path, sizeof(path));
if (!ReadAirspace(airspace_database, path))
StartupStore(TEXT("No airspace file 2\n"));
}
// Calculate the airspace boundaries
FindAirspaceAreaBounds(airspace_database);
FindAirspaceCircleBounds(airspace_database);
if (terrain != NULL) {
terrain->Lock();
airspace_database.UpdateAGL(*terrain);
terrain->Unlock();
}
}
char* ts_strdup_unicode_to_ascii(const unsigned short* str)
{
char* result = (char*)malloc(wcslen((const wchar_t *)str)+1);
if (result == NULL)
return NULL;
unicode2ascii((const wchar_t *)str, result);
return result;
}
char* ts_strcat(char* dest, const unsigned short* src)
{
char* p = dest;
while (*p != '\0')
p++;
unicode2ascii((const wchar_t *)src, p);
return dest;
}
/* ARGSUSED */
static void
output_trans2_querypath(int flags, uchar_t *data, char *xtra, int xsz)
{
int length;
char filename[256];
if (flags & F_SUM) {
length = snprintf(xtra, xsz, " QueryPathInfo");
xtra += length;
xsz -= length;
data += 6;
(void) unicode2ascii(filename, 256, data, 512);
snprintf(xtra, xsz, " File=%s", filename);
}
if (flags & F_DTAIL) {
show_line("FunctionName = QueryPathInfo");
show_printf("InfoLevel = 0x%.4x", get2(data));
data += 6;
(void) unicode2ascii(filename, 256, data, 512);
show_printf("FileName = %s", filename);
}
}
bool
ReadWayPointZipFile(const TCHAR *path, WayPointList &way_points,
RasterTerrain &terrain)
{
char path_ascii[MAX_PATH];
ZZIP_FILE *fp;
unicode2ascii(path, path_ascii, sizeof(path_ascii));
fp = zzip_fopen(path_ascii, "rt");
if (fp == NULL)
return false;
ReadWayPointFile(fp, path, way_points, terrain);
zzip_fclose(fp);
return true;
}
static BOOL wildcardFindFirst(const char* arg, HANDLE* findHandle, char** expandedArg)
{
WIN32_FIND_DATA findData;
WCHAR argW[1024];
int filenameLen;
ascii2unicode(arg, argW, 1024);
*findHandle = FindFirstFile(argW, &findData);
if (*findHandle == (HANDLE)0xffffffff)
return FALSE;
filenameLen = wcslen(findData.cFileName);
*expandedArg = (char*)malloc(filenameLen+1);
if (*expandedArg == NULL)
return FALSE;
unicode2ascii(findData.cFileName, *expandedArg, filenameLen+1);
return TRUE;
}
// ---------------------------------------------------------------------------
// ExportToXML()
//
// ---------------------------------------------------------------------------
void
O2Boards::
ExportToXML(string &out)
{
wstring xml;
xml += L"<?xml version=\"1.0\" encoding=\"";
xml += _T(DEFAULT_XML_CHARSET);
xml += L"\"?>" EOL;
xml += L"<boards>" EOL;
ExLock.Lock();
{
for (O2BoardExMapIt it = exmap.begin(); it != exmap.end(); it++) {
xml_AddElement(xml, L"board", NULL, it->first.c_str());
}
}
ExLock.Unlock();
xml += L"</boards>" EOL;
unicode2ascii(xml, out);
}
static BOOL wildcardFindNext(HANDLE findHandle, char** expandedArg)
{
WIN32_FIND_DATA findData;
int filenameLen;
if (!FindNextFile(findHandle, &findData))
{
FindClose(findHandle);
return FALSE;
}
filenameLen = wcslen(findData.cFileName);
*expandedArg = (char*)malloc(filenameLen+1);
if (*expandedArg == NULL)
{
FindClose(findHandle);
return FALSE;
}
unicode2ascii(findData.cFileName, *expandedArg, filenameLen+1);
return TRUE;
}
bool
ReadWayPointFile(const TCHAR *path, WayPointList &way_points,
RasterTerrain &terrain)
{
char path_ascii[MAX_PATH];
FILE *fp;
unicode2ascii(path, path_ascii, sizeof(path_ascii));
fp = fopen(path_ascii, "rt");
if (fp == NULL)
/* fall back to ReadWayPointZipFile() if the file was not found */
return
#ifdef HAVE_POSIX
errno == ENOTDIR &&
#endif
ReadWayPointZipFile(path, way_points, terrain);
ReadWayPointFile(fp, path, way_points, terrain);
fclose(fp);
return true;
}
// Init Live Tracker services, if available
void LiveTrackerInit()
{
if (LiveTrackerInterval == 0) {
// If livetracker is not enabled at startup, we do nothing,
// but in this case LK must be restarted, if user enables it!
StartupStore(TEXT(". LiveTracker disabled.%s"), NEWLINE);
return;
}
//Init winsock if available
if (InitWinsock()) {
_ws_inited = true;
_hNewDataEvent = CreateEvent(NULL, TRUE, FALSE, TEXT("livetrknewdata"));
// Create a thread for sending data to the server
if ((_hThread = CreateThread (NULL, 0, (LPTHREAD_START_ROUTINE)&LiveTrackerThread, 0, 0, &_dwThreadID)) != NULL)
{
SetThreadPriority(_hThread, THREAD_PRIORITY_NORMAL);
unicode2ascii(LiveTrackersrv_Config, _server_name, SERVERNAME_MAX);
_server_name[SERVERNAME_MAX-1]=0;
StartupStore(TEXT(". LiveTracker will use server %s if available.%s"), LiveTrackersrv_Config, NEWLINE);
_inited = true;
}
}
if (!_inited) StartupStore(TEXT(". LiveTracker init failed.%s"),NEWLINE);
}
void
TopWindow::set(LPCTSTR cls, LPCTSTR text,
int left, int top, unsigned width, unsigned height)
{
#ifdef ENABLE_SDL
int ret;
ret = ::SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER);
if (ret != 0)
fprintf(stderr, "SDL_Init() has failed\n");
ret = ::TTF_Init();
if (ret != 0)
fprintf(stderr, "TTF_Init() has failed: %s\n", TTF_GetError());
screen.set();
ContainerWindow::set(NULL, 0, 0, width, height);
char text2[512];
unicode2ascii(text, text2);
::SDL_WM_SetCaption(text2, NULL);
#else /* !ENABLE_SDL */
Window::set(NULL, cls, text, left, top, width, height,
(DWORD)(WS_SYSMENU|WS_CLIPCHILDREN|WS_CLIPSIBLINGS));
#if defined(GNAV) && !defined(PCGNAV)
// TODO code: release the handle?
HANDLE hTmp = LoadIcon(XCSoarInterface::hInst,
MAKEINTRESOURCE(IDI_XCSOARSWIFT));
SendMessage(hWnd, WM_SETICON,
(WPARAM)ICON_BIG, (LPARAM)hTmp);
SendMessage(hWnd, WM_SETICON,
(WPARAM)ICON_SMALL, (LPARAM)hTmp);
#endif
#endif /* !ENABLE_SDL */
}
static void navigation_task(struct state_machine_context *state_m)
{
static size_t item_updated;
static uint16_t temp_cursor_pos;
size_t i;
// By default, the command executed is asynchronous.
state_m->async_cmd = true;
state_m->view = GUI_UPDATE_VIEW_NAVIGATION;
switch (state_m->state)
{
// This state id the entry point of the navigation view.
// It must be call on every access to this view.
case STATE_NAVIGATION_ENTRY_POINT:
state_m->view_elt = GUI_UPDATE_ELT_NAVIGATION_CURSOR;
state_m->async_cmd = false;
state_m->cmd_status = true;
// Update file_list relatives info.
state_m->list.file_pos = 0;
state_m->list.nb_files = 0xFFFF;
state_m->list.nb_valid_entries = 0;
temp_cursor_pos = 0;
state_m->cursor_pointer = 0;
// Invalidate all the items on the list
for (i=0; i<MAX_BUFFER_FILE; i++)
state_m->list.list[i].updated = false;
state_m->state = STATE_NAVIGATION_UPDATE_LIST;
break;
// Update the file list from the current directory.
case STATE_NAVIGATION_UPDATE_LIST:
// Re-center the file list.
if (temp_cursor_pos < state_m->list.file_pos &&
state_m->list.nb_valid_entries)
{
// Scroll-down the list
memmove((void *) &state_m->list.list[1],
(const void *) &state_m->list.list[0],
sizeof(state_m->list.list[0])*(MAX_BUFFER_FILE - 1));
// Every element of the list have to be updated
for (i=1; i<MAX_BUFFER_FILE; i++)
state_m->list.list[i].updated = true;
// Get information of the file.
item_updated = 0;
state_m->list.file_pos--;
state_m->list.nb_valid_entries--;
ai_async_nav_file_goto(state_m->list.file_pos + item_updated);
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_LIST_GET_NAME;
break;
}
if (temp_cursor_pos > state_m->list.file_pos &&
state_m->list.nb_valid_entries)
{
// Scroll-up the list
memmove((void *) &state_m->list.list[0],
(const void *) &state_m->list.list[1],
sizeof(state_m->list.list[0])*(MAX_BUFFER_FILE - 1));
// Every element of the list have to be updated
for (i=0; i<MAX_BUFFER_FILE-1; i++)
state_m->list.list[i].updated = true;
// Get information of the file.
item_updated = MAX_BUFFER_FILE - 1;
state_m->list.file_pos++;
state_m->list.nb_valid_entries--;
ai_async_nav_file_goto(state_m->list.file_pos + item_updated);
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_LIST_GET_NAME;
break;
}
// There is nothing to update
state_m->async_cmd = false;
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_WAIT_FOR_EVENT;
break;
// Read the file name of the file selected.
case STATE_NAVIGATION_UPDATE_LIST_GET_NAME:
// The case when there is no more files...
if (state_m->cmd_status == false)
{
state_m->list.nb_files = state_m->list.file_pos + item_updated;
// If no files/folders are found in the current directory...
if (!state_m->list.nb_files)
state_m->view_elt |= GUI_UPDATE_ELT_NAVIGATION_NO_FILES;
state_m->cmd_status = true;
state_m->async_cmd = false;
navigation_update_view(state_m);
state_m->state = STATE_NAVIGATION_WAIT_FOR_EVENT;
break;
}
ai_async_nav_file_name();
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_LIST_STORE_NAME;
break;
// Store the file name of the selected file.
case STATE_NAVIGATION_UPDATE_LIST_STORE_NAME:
unicode2ascii((char *) state_m->list.list[item_updated].file_name,
(const char *) ai_async_cmd_out_PtrArrayU8(),
Min(ai_async_cmd_out_SizeArrayU8(), STR_MAX_LENGTH*2));
ai_async_nav_file_isdir();
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_ISDIR;
break;
// Check if the selected file is a directory or not.
case STATE_NAVIGATION_UPDATE_ISDIR:
state_m->list.list[item_updated].type = (ai_async_cmd_out_u32())?FILE_TYPE_DIRECTORY:FILE_TYPE_FILE;
state_m->list.list[item_updated].updated = true;
state_m->list.nb_valid_entries++;
navigation_update_view(state_m);
state_m->async_cmd = false;
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_LIST;
break;
// This state is the "idle" state of this view.
case STATE_NAVIGATION_WAIT_FOR_EVENT:
// Catch new track event
state_m->cmd_status = true;
if (state_m->player_status.flags.new_file_played)
{
state_m->async_cmd = false;
state_m->player_status.flags.new_file_played = 0;
state_m->recorded_state = STATE_NAVIGATION_WAIT_FOR_EVENT;
state_m->state = STATE_TRACK_CHANGED_ENTRY_POINT;
break;
}
// Switch to playback view
else if (controller_switch_to_playback_view(GUI_UPDATE_VIEW_NAVIGATION))
{
controller_clear();
state_m->async_cmd = false;
state_m->state = STATE_PLAYBACK_ENTRY_POINT;
break;
}
// Switch to configuration view
else if (controller_switch_to_config_view(GUI_UPDATE_VIEW_NAVIGATION))
{
controller_clear();
state_m->async_cmd = false;
state_m->state = STATE_CONFIG_ENTRY_POINT;
break;
}
// Go up in the file list.
else if (controller_navigation_cursor_previous() &&
temp_cursor_pos)
{
state_m->async_cmd = false;
temp_cursor_pos--;
state_m->state = STATE_NAVIGATION_UPDATE_LIST;
break;
}
// Go down in the file list.
else if (controller_navigation_cursor_next() &&
(temp_cursor_pos + 1 < state_m->list.file_pos + state_m->list.nb_valid_entries))
{
state_m->async_cmd = false;
temp_cursor_pos++;
state_m->state = STATE_NAVIGATION_UPDATE_LIST;
break;
}
// Enter directory of play the file.
else if (controller_navigation_change_directory())
{
if (navigation_get_current_file_type(state_m) == FILE_TYPE_FILE)
{
ai_async_nav_file_goto(temp_cursor_pos);
state_m->state = STATE_NAVIGATION_PLAY_SELECTED_FILE;
break;
}
else
{
ai_async_nav_file_goto(temp_cursor_pos);
state_m->state = STATE_NAVIGATION_CD;
break;
}
}
// Go to parent directory.
else if (controller_navigation_go_to_parent_directory())
{
ai_async_nav_file_goto(temp_cursor_pos);
state_m->state = STATE_NAVIGATION_GOTOPARENT;
break;
}
// Play the file or the directory.
else if (controller_navigation_play())
{
ai_async_nav_file_goto(temp_cursor_pos);
state_m->state = STATE_NAVIGATION_PLAY_SELECTED_FILE;
break;
}
// Fill the file list with valid data.
else if (state_m->list.nb_valid_entries < MAX_BUFFER_FILE &&
state_m->list.file_pos + state_m->list.nb_valid_entries < state_m->list.nb_files)
{
item_updated = state_m->list.nb_valid_entries;
ai_async_nav_file_goto(state_m->list.file_pos + state_m->list.nb_valid_entries);
state_m->view_elt |= GUI_UPDATE_ELT_IN_PROGRESS;
state_m->state = STATE_NAVIGATION_UPDATE_LIST_GET_NAME;
break;
}
state_m->async_cmd = false;
state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT;
state_m->recorded_state = STATE_NAVIGATION_WAIT_FOR_EVENT;
break;
// Enter directory.
case STATE_NAVIGATION_CD:
ai_async_nav_dir_cd();
state_m->state = STATE_NAVIGATION_ENTRY_POINT;
break;
// Go to parent directory.
case STATE_NAVIGATION_GOTOPARENT:
state_m->cmd_status = true;
ai_async_nav_dir_gotoparent();
state_m->state = STATE_NAVIGATION_GOTOPARENT_ERROR_HANDLING;
break;
// This state handle a gotoparent error.
case STATE_NAVIGATION_GOTOPARENT_ERROR_HANDLING:
state_m->async_cmd = false;
if (state_m->cmd_status == false)
state_m->state = STATE_NAVIGATION_WAIT_FOR_EVENT;
else
state_m->state = STATE_NAVIGATION_ENTRY_POINT;
state_m->cmd_status = true;
break;
// This states play the file selected by the cursor.
case STATE_NAVIGATION_PLAY_SELECTED_FILE:
if (state_m->cmd_status)
ai_async_audio_nav_playfile();
else
{
state_m->cmd_status = true;
state_m->async_cmd = false;
state_m->state = STATE_NAVIGATION_ENTRY_POINT;
break;
}
state_m->state = STATE_NAVIGATION_WAIT_FOR_SELECTION;
break;
// This states makes sure the file has been selected
case STATE_NAVIGATION_WAIT_FOR_SELECTION:
// If we were not able to play the selected song, then play any song
if (!state_m->cmd_status)
{
state_m->cmd_status = true;
state_m->state = STATE_COMMAND_PLAY_ANY_SONG;
}
else
state_m->state = STATE_CHECK_DEVICE_ENTRY_POINT;
state_m->recorded_state = STATE_NAVIGATION_UPDATE_METADATA_AND_PLAY;
state_m->async_cmd = false;
break;
// This state update the status of the audio player.
case STATE_NAVIGATION_UPDATE_METADATA_AND_PLAY:
state_m->async_cmd = false;
state_m->player_status.flags.new_file_played = 0;
state_m->recorded_state = STATE_PLAYBACK_ENTRY_POINT;
state_m->state = STATE_TRACK_CHANGED_ENTRY_POINT;
break;
default:
return;
}
// Error management.
if (state_m->cmd_status == false)
state_m->state = STATE_NAVIGATION_WAIT_FOR_EVENT;
}
/* ARGSUSED */
static void
interpret_negprot(int flags, uchar_t *data, int len, char *xtra, int xsz)
{
int i, last, length;
int bytecount;
int key_len;
int wordcount;
char tbuf[256];
struct smb *smbdata;
uchar_t *protodata;
uchar_t *byte0;
uint64_t nttime;
uint32_t caps;
ushort_t smb_flags2;
smbdata = (struct smb *)data;
smb_flags2 = get2(smbdata->flags2);
protodata = (uchar_t *)data + sizeof (struct smb);
wordcount = *protodata++;
if ((smbdata->flags & SERVER_RESPONSE) == 0) {
/*
* request packet:
* short bytecount;
* struct { char fmt; char name[]; } dialects
*/
bytecount = get2(protodata);
protodata += 2;
byte0 = protodata;
if (flags & F_DTAIL)
show_printf("ByteCount = %d", bytecount);
if (bytecount > len)
bytecount = len;
/* Walk the list of dialects. */
i = last = 0;
tbuf[0] = '\0';
while (protodata < (byte0 + bytecount - 2)) {
if (*protodata++ != 2) /* format code */
break;
length = strlcpy(tbuf, (char *)protodata,
sizeof (tbuf));
protodata += (length + 1);
if (flags & F_DTAIL) {
show_printf("Dialect[%d] = %s",
i, tbuf);
}
last = i++;
}
if (flags & F_SUM) {
/*
* Just print the last dialect, which is
* normally the interesting one.
*/
snprintf(xtra, xsz, " Dialect[%d]=%s", last, tbuf);
}
} else {
/* Parse reply */
if (flags & F_SUM) {
snprintf(xtra, xsz, " Dialect#=%d", protodata[0]);
}
if ((flags & F_DTAIL) == 0)
return;
if (wordcount < 13)
return;
show_printf("WordCount = %d", wordcount);
show_printf("Dialect Index = %d", protodata[0]);
protodata += 2;
show_printf("Security Mode = 0x%x", protodata[0]);
protodata++;
show_printf("MaxMPXRequests = %d", get2(protodata));
protodata += 2;
show_printf("MaxVCs = %d", get2(protodata));
protodata += 2;
show_printf("MaxBufferSize = %d", get4(protodata));
protodata += 4;
show_printf("MaxRawBuffer = %d", get4(protodata));
protodata += 4;
show_printf("SessionKey = 0x%.8x", get4(protodata));
protodata += 4;
caps = get4(protodata);
protodata += 4;
show_printf("Capabilities = 0x%.8x", caps);
/* Server Time */
nttime = get8(protodata);
protodata += 8;
show_printf("Server Time = %s", format_nttime(nttime));
show_printf("Server TZ = %d", get2(protodata));
protodata += 2;
key_len = *protodata++;
show_printf("KeyLength = %d", key_len);
bytecount = get2(protodata);
protodata += 2;
show_printf("ByteCount = %d", bytecount);
if (smb_flags2 & FLAGS2_EXT_SEC) {
show_printf("Server GUID (16)");
output_bytes(protodata, 16);
protodata += 16;
show_printf("Security Blob (SPNEGO)");
output_bytes(protodata, bytecount - 16);
} else {
show_printf("NTLM Challenge: (%d)", key_len);
output_bytes(protodata, key_len);
protodata += key_len;
/*
* Get Unicode from capabilities here,
* as flags2 typically doesn't have it.
* Also, this one is NOT aligned!
*/
tbuf[0] = '\0';
if (caps & 4) {
(void) unicode2ascii(tbuf, sizeof (tbuf),
protodata, 2 * sizeof (tbuf));
} else {
(void) strlcpy(tbuf, (char *)protodata,
sizeof (tbuf));
}
show_printf("Server Domain = %s", tbuf);
}
}
}
void
O2Profile_SAX2Handler::
endElement(const XMLCh* const uri
, const XMLCh* const localname
, const XMLCh* const qname)
{
switch (CurElm) {
case PROF_XMLELM_ID:
Profile->ID.assign(buf.c_str(), buf.size());
break;
case PROF_XMLELM_PRIVKEY:
Profile->PrivKey.assign(buf.c_str(), buf.size());
break;
case PROF_XMLELM_PUBKEY:
Profile->PubKey.assign(buf.c_str(), buf.size());
break;
case PROF_XMLELM_IP:
Profile->IP = e2ip(buf.c_str(), buf.size());
break;
case PROF_XMLELM_P2PPORT:
Profile->P2PPort = (ushort)wcstoul(buf.c_str(), NULL, 10);
break;
case PROF_XMLELM_PROXYPORT:
Profile->ProxyPort = (ushort)wcstoul(buf.c_str(), NULL, 10);
break;
case PROF_XMLELM_ADMINPORT:
Profile->AdminPort = (ushort)wcstoul(buf.c_str(), NULL, 10);
break;
case PROF_XMLELM_NAME:
if (buf.size() <= O2_MAX_NAME_LEN) {
Profile->SetNodeName(buf.c_str());
}
break;
case PROF_XMLELM_COMMENT:
if (buf.size() <= O2_MAX_COMMENT_LEN) {
for (size_t i = 0; i < buf.size(); i++) {
if (buf[i] == L'\n')
Profile->Comment += L"\r\n";
else
Profile->Comment += buf[i];
}
}
break;
case PROF_XMLELM_DBDIR:
Profile->SetDBDir(buf.c_str());
break;
case PROF_XMLELM_CACHEROOT:
Profile->SetCacheRoot(buf.c_str());
break;
case PROF_XMLELM_ADMINROOT:
Profile->SetAdminRoot(buf.c_str());
break;
case PROF_XMLELM_ADMIN_BROWSER_TYPE:
Profile->AdminBrowserType = buf;
break;
case PROF_XMLELM_ADMIN_BROWSER_PATH:
Profile->AdminBrowserPath = buf;
break;
case PROF_XMLELM_UPNP_ADAPTERNAME:
unicode2ascii(buf, Profile->UPnPAdapterName);
break;
case PROF_XMLELM_UPNP_LOCATION:
unicode2ascii(buf, Profile->UPnPLocation);
break;
case PROF_XMLELM_UPNP_SERVICEID:
unicode2ascii(buf, Profile->UPnPServiceId);
break;
case PROF_XMLELM_LIMIT:
if (plimit)
*plimit = wcstoul(buf.c_str(), NULL, 10);
break;
case PROF_XMLELM_SIZE_T:
if (puint64)
*puint64 = _wcstoui64(buf.c_str(), NULL, 10);
break;
case PROF_XMLELM_BOOL:
*pbool = buf[0] == '1' ? true : false;
break;
}
buf = L"";
CurElm = PROF_XMLELM_NONE;
if (!MATCHLNAME(L"profile"))
return;
if (Profile->PrivKey.size() != RSA_PRIVKEY_SIZE
|| Profile->PubKey.size() != RSA_PUBKEY_SIZE) {
Profile->SetRSAKey(NULL, 0, NULL, 0);
}
}
static bool SendStartOfTrackPacket(unsigned int *packet_id, unsigned int *session_id, int userid)
{
char username[128];
char password[128];
char txbuf[500];
char rxbuf[32];
int rxlen;
char phone[64];
char gps[64];
unsigned int vehicle_type = 8;
char vehicle_name[64];
int rnd;
TCHAR wgps[254];
if (1) {
CCriticalSection::CGuard guard(_t_mutex);
// START OF TRACK PACKET
// /track.php?leolive=2&sid=42664778&pid=1&client=YourProgramName&v=1&user=yourusername&pass=yourpass&phone=Nokia 2600c&gps=BT GPS&trk1=4&vtype=16388&vname=vehicle name and model
// PARAMETERS
// leolive=2 // 2 means this is the start of track packet
// sid=42664778 // the session ID , see below on sessionID section for more information
// pid=1 // the packet numner of this packet, we start with 1 and increase with each packet send either start/end or with GPS data.
// client=YourClientName// fixed value use only alphanumerics no spaces, first Letter of words in capitals
// user=yourusername // there is no need to have a registered user, the user can input his preferred username on the fly, he will be displayed in black instead of blue if not registered.
// pass=yourpass
// v=1 // version of your program you can use free text like 1.4.5
// trk1=4 // the interval in secs that we will be sending gps points
// phone=Nokia 2600c // the phone model as it is acquired from a system call
// &gps=BT GPS // the GPS name , use the string Internal GPS for phones with integrated GPS
// vname // the brand + name of the vehicle/glider ie Gradient Golden 2 26
//
// Values for vtype
// 1=>"Paraglider"
// 8=>"Glider"
// 64=>"Powered flight"
// 17100=>"Car"
if (_tcslen(LiveTrackerusr_Config)>0 ) {
unicode2ascii(LiveTrackerusr_Config, txbuf, sizeof(txbuf));
} else {
strncpy(txbuf, "guest", sizeof(txbuf));
}
UrlEncode(txbuf, username, sizeof(username));
if (_tcslen(LiveTrackerpwd_Config)>0 ) {
unicode2ascii(LiveTrackerpwd_Config, txbuf, sizeof(txbuf));
} else {
strncpy(txbuf, "guest", sizeof(txbuf));
}
UrlEncode(txbuf, password, sizeof(password));
#ifdef PNA
unicode2ascii(GlobalModelName, txbuf, sizeof(txbuf));
UrlEncode(txbuf, phone, sizeof(phone));
#else
#if (WINDOWSPC>0)
UrlEncode("PC", phone, sizeof(phone));
#else
UrlEncode("PDA", phone, sizeof(phone));
#endif
#endif
if (SIMMODE) UrlEncode("SIMULATED", gps, sizeof(gps));
else {
GetBaroDeviceName(_t_barodevice, wgps);
unicode2ascii(wgps, txbuf, sizeof(txbuf));
UrlEncode(txbuf, gps, sizeof(gps));
}
unicode2ascii(AircraftType_Config, txbuf, sizeof(txbuf));
UrlEncode(txbuf, vehicle_name, sizeof(vehicle_name));
vehicle_type = 8;
if (AircraftCategory == umParaglider) vehicle_type = 1;
if (AircraftCategory == umCar) vehicle_type = 17100;
if (AircraftCategory == umGAaircraft) vehicle_type = 64;
*packet_id = 1;
rnd = rand();
*session_id = ( (rnd<<24) & 0x7F000000 ) | ( userid & 0x00ffffff) | 0x80000000;
sprintf(txbuf,"GET /track.php?leolive=2&sid=%u&pid=1&client=%s&v=%s%s&user=%s&pass=%s&phone=%s&gps=%s&trk1=%u&vtype=%u&vname=%s HTTP/1.0\r\nHost: %s\r\n\r\n",
*session_id,
LKFORK,LKVERSION,LKRELEASE,
username, password,
phone, gps,
LiveTrackerInterval,
vehicle_type,
vehicle_name,
_server_name);
}
rxlen = DoTransactionToServer(txbuf, strlen(txbuf), rxbuf, sizeof(rxbuf));
if (rxlen==2 && rxbuf[0]=='O' && rxbuf[1]=='K') {
(*packet_id)++;
return true;
}
return false;
}
bool
O2IPFilter::
add(bool enable, uint flag, const wchar_t *cond, bool do_add)
{
O2IPFilterRecord filter;
if (flag != O2_ALLOW && flag != O2_DENY)
return false;
filter.enable = enable;
filter.flag = flag;
filter.cond = cond;
string condstr;
unicode2ascii(cond, wcslen(cond), condstr);
size_t pos = condstr.find_first_not_of("0123456789./");
if (!FOUND(pos)) {
string ip;
string mask;
pos = condstr.find('/');
if (FOUND(pos)) {
ip = condstr.substr(0, pos);
mask = condstr.substr(pos+1);
}
else
ip = condstr;
strarray iptoken;
if (split(ip.c_str(), ".", iptoken) == 0)
return false;
switch (iptoken.size()) {
case 1:
ip += ".0.0.0";
filter.ip = inet_addr(ip.c_str());
filter.mask = inet_addr("255.0.0.0");
break;
case 2:
ip += ".0.0";
filter.ip = inet_addr(ip.c_str());
filter.mask = inet_addr("255.255.0.0");
break;
case 3:
ip += ".0";
filter.ip = inet_addr(ip.c_str());
filter.mask = inet_addr("255.255.255.0");
break;
case 4:
filter.ip = inet_addr(ip.c_str());
filter.mask = inet_addr("255.255.255.255");
break;
}
if (filter.ip == INADDR_NONE)
return false;
if (!mask.empty()) {
if (!FOUND(mask.find('.'))) {
int bitnum = atoi(mask.c_str());
if (bitnum > 32)
return false;
ulong m = 0;
for (int i = 0; i < bitnum; i++)
m |= (1<<(31-i));
filter.mask = htonl(m);
}
else {
if (mask == "255.255.255.255")
filter.mask = 0xffffffff;
else {
filter.mask = inet_addr(mask.c_str());
if (filter.mask == INADDR_NONE)
return false;
}
}
}
}
else {
boost::wregex::flag_type f = boost::regex_constants::normal
| boost::regex_constants::icase;
boost::wregex regex(L"^[a-z0-9][a-z0-9.-]+[a-z0-9]$", f);
if (!boost::regex_search(cond, regex))
return false;
filter.host = L".";
filter.host += cond;
}
if (do_add) {
Lock();
records.push_back(filter);
Unlock();
}
/*
wchar_t abc[256];
wstring is, ms;
ulong2ipstr(filter.ip, is);
ulong2ipstr(filter.mask, ms);
swprintf(abc, L"IP:%s MASK:%s HOST:%s", is.c_str(), ms.c_str(), filter.host.c_str());
MessageBoxW(NULL,abc,NULL,MB_OK);
*/
return true;
}
// if childData is NULL, the size will be returned in childDataLen
bool ChildData::decode(void* childData)//, int childDataSize)
{
bool result = false;
int strLen;
if (childData == NULL)// || childDataSize < sizeof(DWORD))
return false;
char* p = (char*)childData;
// total size
DWORD size;
memcpy(&size, p, sizeof(DWORD));
p += sizeof(DWORD);
// // check that size encoded in buffer isn't bigger that passed-in size
// if (size > childDataSize)
// return false;
size -= sizeof(DWORD);
// reserved (ignore)
p += sizeof(DWORD);
size -= sizeof(DWORD);
// get current directory
strLen = ts_strlen((WCHAR*)p);
if ((strLen+1)*2 > (int)size)
goto cleanup;
if (strLen == 0)
resetCurrentDirectory();
else
{
#ifdef UNICODE
setCurrentDirectory((WCHAR*)p);
#else
char buf[256];
unicode2ascii((WCHAR*)p, buf);
setCurrentDirectory(buf);
#endif
}
p += (strLen + 1) * 2;
size -= (strLen + 1)*2;
// num redirs
memcpy(&numRedirArgs, p, sizeof(DWORD));
p += sizeof(DWORD);
size -= sizeof(DWORD);
// allocate redirs array
if (redirArgs != NULL)
free(redirArgs);
redirArgs = (RedirArg*)malloc(sizeof(RedirArg)*numRedirArgs);
if (redirArgs == NULL)
goto cleanup;
// redirs
{
for (int i=0; i<numRedirArgs; i++)
{
// flags
DWORD flags;
memcpy(&flags, p, sizeof(DWORD));
p += sizeof(DWORD);
size -= sizeof(DWORD);
switch (flags&0x00000003)
{
case 0:
redirArgs[i].redirType = RT_PIPE_UNSPEC;
break;
case 1:
redirArgs[i].redirType = RT_FILE;
break;
case 2:
redirArgs[i].redirType = RT_HANDLE;
break;
}
bool filenamePresent = false;
if (flags & 0x00000004)
filenamePresent = true;
redirArgs[i].append = ((flags & 0x00000008) != 0);
redirArgs[i].openForRead = ((flags & 0x00000010) != 0);
redirArgs[i].openForWrite = ((flags & 0x00000020) != 0);
// fd
memcpy(&redirArgs[i].fd, p, sizeof(DWORD));
p += sizeof(DWORD);
size -= sizeof(DWORD);
// fd2
memcpy(&redirArgs[i].fd2, p, sizeof(DWORD));
p += sizeof(DWORD);
size -= sizeof(DWORD);
// pipe/file name
if (filenamePresent)
{
int strLen = ts_strlen((WCHAR*)p);
if ((strLen+1)*2 > (int)size)
goto cleanup;
redirArgs[i].filename = _tcsdup((WCHAR*)p);
p += (strLen + 1)*2;
size -= (strLen + 1)*2;
}
else
redirArgs[i].filename = NULL;
}
}
// get environment
if (size <= 0)
return false;
p += sizeof(DWORD); // skip env size
resetEnvironment();
addEnvironmentList((WCHAR*)p);
// success
result = true;
cleanup:
return result;
}
// generate argc/argv from program name and lpCmdLine
// returns 0 on failure, or argc on success
int processCmdLine(LPTSTR lpCmdLine, char*** pArgv)
{
BOOL success = FALSE;
int argc = 0;
char** argv = NULL;
TCHAR programName[1024];
const int maxArgChars = 1024;
TCHAR argW[maxArgChars];
char arg[maxArgChars];
ArgType argType;
// get program name
if (GetModuleFileName(NULL, programName, 1024) <= 0)
goto cleanup;
programName[1023] = 0; // make sure it's terminated when result is truncated
// add program name to args
argc++;
argv = (char**)realloc(argv, argc*sizeof(char*));
if (argv == NULL)
goto cleanup;
argv[argc-1] = (char*)malloc((wcslen(programName)+1)*2);
if (argv[argc-1] == NULL)
goto cleanup;
unicode2ascii(programName, argv[argc-1], wcslen(programName)+1);
while ((argType = getCmdLineArg(&lpCmdLine, argW, maxArgChars, NULL, NULL)) > 0)
{
ts_strcpy(arg, argW); // convert to unicode (if we're in unicode)
if (argType == TOK_STRING)
{
HANDLE findHandle;
char* expandedArg;
if ((strchr(arg,'*')==NULL && strchr(arg,'?')==NULL) || !wildcardFindFirst(arg, &findHandle, &expandedArg))
{ // not a wildcard, or is but doesn't match anything, so just add arg to argv
argc++;
argv = (char**)realloc(argv, argc*sizeof(char*));
if (argv == NULL)
goto cleanup;
argv[argc-1] = (char*)malloc(strlen(arg)+1);
if (argv[argc-1] == NULL)
goto cleanup;
strcpy(argv[argc-1], arg);
}
else
{ // handle wildcards
int firstExpandedArgIndex = argc;
int lastExpandedArgIndex = argc;
int numPathCharsToCopyFromArg = 0;
char* lastSlash = max(strrchr(arg,'\\'), strrchr(arg,'/'));
if (lastSlash != NULL)
numPathCharsToCopyFromArg = lastSlash - arg + 1;
do
{
argc++;
argv = (char**)realloc(argv, argc*sizeof(char*));
if (argv == NULL)
{
free(expandedArg);
goto cleanup;
}
if (numPathCharsToCopyFromArg == 0)
argv[argc-1] = expandedArg;
else
{
argv[argc-1] = (char*)malloc(numPathCharsToCopyFromArg + strlen(expandedArg) + 1);
if (argv[argc-1] == NULL)
goto cleanup;
strncpy(argv[argc-1], arg, numPathCharsToCopyFromArg);
strcpy(argv[argc-1]+numPathCharsToCopyFromArg, expandedArg);
}
lastExpandedArgIndex = argc-1;
} while (wildcardFindNext(findHandle, &expandedArg));
qsort(&argv[firstExpandedArgIndex], lastExpandedArgIndex-firstExpandedArgIndex+1, sizeof(char*), qsort_stricmp);
}
}
}
// success
success = TRUE;
cleanup:
if (!success)
{
if (argv != NULL)
{
int i;
for (i=0; i<argc; i++)
free(argv[i]);
free(argv);
}
argc = 0;
}
else
*pArgv = argv;
return argc;
}
static void track_changed_task(struct state_machine_context *state_m)
{
// By default, the command executed is asynchronous.
state_m->async_cmd = true;
Ai_player_flag_t player_flag_temp;
switch (state_m->state)
{
case STATE_TRACK_CHANGED_ENTRY_POINT:
memset(&state_m->info, 0, sizeof(struct file_info));
ai_async_audio_nav_file_info_duration();
state_m->state = STATE_TRACK_CHANGED_TOTAL_TIME;
break;
// Record total time info and call file name.
case STATE_TRACK_CHANGED_TOTAL_TIME:
state_m->info.total_time = ai_async_cmd_out_u32();
ai_async_audio_nav_getname();
state_m->state = STATE_TRACK_CHANGED_FILE_NAME;
break;
// Record file name information and call for artist metadata.
case STATE_TRACK_CHANGED_FILE_NAME:
unicode2ascii((char *) state_m->info.name,
(const char *) ai_async_cmd_out_PtrArrayU8(),
Min(ai_async_cmd_out_SizeArrayU8(), STR_MAX_LENGTH*2));
ai_async_audio_nav_file_info_artist();
state_m->state = STATE_TRACK_CHANGED_ARTIST;
break;
// Record artist metadata and call title metadata.
case STATE_TRACK_CHANGED_ARTIST:
unicode2ascii((char *) state_m->info.artist,
(const char *) ai_async_cmd_out_PtrArrayU8(),
Min(ai_async_cmd_out_SizeArrayU8(), STR_MAX_LENGTH*2));
ai_async_audio_nav_file_info_title();
state_m->state = STATE_TRACK_CHANGED_TITLE;
break;
// Record title metadata.
case STATE_TRACK_CHANGED_TITLE:
unicode2ascii((char *) state_m->info.title,
(const char *) ai_async_cmd_out_PtrArrayU8(),
Min(ai_async_cmd_out_SizeArrayU8(), STR_MAX_LENGTH*2));
#if defined(SUPPORT_EMBEDDED_COVER_ARTS) && SUPPORT_EMBEDDED_COVER_ARTS == true
state_m->info.size.width = 100;
state_m->info.size.height = 100;
ai_async_audio_nav_file_info_image(&state_m->info.size);
state_m->state = STATE_TRACK_CHANGED_IMAGE;
#else
ai_async_audio_ctrl_status();
state_m->state = STATE_TRACK_CHECK_RESUME;
#endif
break;
// Record image data.
case STATE_TRACK_CHANGED_IMAGE:
state_m->info.image_data = (void *) ai_async_cmd_out_u32();
ai_async_audio_ctrl_status();
state_m->state = STATE_TRACK_CHECK_RESUME;
break;
// Resume the track
case STATE_TRACK_CHANGED_RESUME:
state_m->async_cmd = false;
state_m->state = state_m->recorded_state;
break;
// Check if the device is in pause before sending a ai_async_audio_ctrl_resume()
// command.
case STATE_TRACK_CHECK_RESUME:
player_flag_temp.all = ai_async_cmd_out_u32();
if (player_flag_temp.status == PLAYER_FLAG_PAUSE)
ai_async_audio_ctrl_resume();
state_m->state = STATE_TRACK_CHANGED_RESUME;
break;
default:
return;
}
// Error management
if (state_m->cmd_status == false)
state_m->state = STATE_DEVICE_DISCONNECTED;
}
void TopologyStore::Open() {
StartupStore(TEXT("OpenTopology\n"));
XCSoarInterface::CreateProgressDialog(gettext(TEXT("Loading Topology File...")));
Poco::ScopedRWLock protect(lock, true);
// Start off by getting the names and paths
static TCHAR szOrigFile[MAX_PATH] = TEXT("\0");
static TCHAR szFile[MAX_PATH] = TEXT("\0");
static TCHAR Directory[MAX_PATH] = TEXT("\0");
for (int z=0; z<MAXTOPOLOGY; z++) {
topology_store[z] = 0;
}
GetRegistryString(szRegistryTopologyFile, szFile, MAX_PATH);
ExpandLocalPath(szFile);
_tcscpy(szOrigFile,szFile); // make copy of original
ContractLocalPath(szOrigFile);
// remove it in case it causes a crash (will restore later)
SetRegistryString(szRegistryTopologyFile, TEXT("\0"));
if (_tcslen(szFile)==0) {
// file is blank, so look for it in a map file
static TCHAR szMapFile[MAX_PATH] = TEXT("\0");
GetRegistryString(szRegistryMapFile, szMapFile, MAX_PATH);
if (_tcslen(szMapFile)==0) {
return;
}
ExpandLocalPath(szMapFile);
// Look for the file within the map zip file...
_tcscpy(Directory,szMapFile);
_tcscat(Directory,TEXT("/"));
szFile[0]=0;
_tcscat(szFile,Directory);
_tcscat(szFile,TEXT("topology.tpl"));
} else {
ExtractDirectory(Directory,szFile);
}
// Ready to open the file now..
static ZZIP_FILE* zFile;
char zfilename[MAX_PATH];
unicode2ascii(szFile, zfilename, MAX_PATH);
zFile = zzip_fopen(zfilename, "rt");
if (!zFile) {
StartupStore(TEXT("No topology file\n%s\n"), szFile);
return;
}
TCHAR ctemp[80];
TCHAR TempString[READLINE_LENGTH+1];
TCHAR ShapeName[50];
double ShapeRange;
long ShapeIcon;
long ShapeField;
TCHAR wShapeFilename[MAX_PATH];
TCHAR *Stop;
int numtopo = 0;
char ShapeFilename[MAX_PATH];
while(ReadString(zFile,READLINE_LENGTH,TempString)) {
if((_tcslen(TempString) > 0)
&& (_tcsstr(TempString,TEXT("*")) != TempString)) // Look For Comment
{
BYTE red, green, blue;
// filename,range,icon,field
// File name
PExtractParameter(TempString, ctemp, 0);
_tcscpy(ShapeName, ctemp);
_tcscpy(wShapeFilename, Directory);
_tcscat(wShapeFilename,ShapeName);
_tcscat(wShapeFilename,TEXT(".shp"));
#ifdef _UNICODE
WideCharToMultiByte( CP_ACP, 0, wShapeFilename,
_tcslen(wShapeFilename)+1,
ShapeFilename,
200, NULL, NULL);
#else
strcpy(ShapeFilename, wShapeFilename);
#endif
// Shape range
PExtractParameter(TempString, ctemp, 1);
ShapeRange = StrToDouble(ctemp,NULL);
// Shape icon
PExtractParameter(TempString, ctemp, 2);
ShapeIcon = _tcstol(ctemp, &Stop, 10);
// Shape field for text display
// sjt 02NOV05 - field parameter enabled
PExtractParameter(TempString, ctemp, 3);
if (_istalnum(ctemp[0])) {
ShapeField = _tcstol(ctemp, &Stop, 10);
ShapeField--;
} else {
ShapeField = -1;
}
// Red component of line / shading colour
PExtractParameter(TempString, ctemp, 4);
red = (BYTE)_tcstol(ctemp, &Stop, 10);
// Green component of line / shading colour
PExtractParameter(TempString, ctemp, 5);
green = (BYTE)_tcstol(ctemp, &Stop, 10);
// Blue component of line / shading colour
PExtractParameter(TempString, ctemp, 6);
blue = (BYTE)_tcstol(ctemp, &Stop, 10);
if ((red==64)
&& (green==96)
&& (blue==240)) {
// JMW update colours to ICAO standard
red = 85; // water colours
green = 160;
blue = 255;
}
if (ShapeField<0) {
Topology* newtopo;
newtopo = new Topology(ShapeFilename, Color(red,green,blue));
topology_store[numtopo] = newtopo;
} else {
TopologyLabel *newtopol;
newtopol = new TopologyLabel(ShapeFilename,
Color(red,green,blue),
ShapeField);
topology_store[numtopo] = newtopol;
}
if (ShapeIcon!=0)
topology_store[numtopo]->loadBitmap(ShapeIcon);
topology_store[numtopo]->scaleThreshold = ShapeRange;
numtopo++;
}
}
zzip_fclose(zFile);
// file was OK, so save it
SetRegistryString(szRegistryTopologyFile, szOrigFile);
}
