998 lines
26 KiB
C
998 lines
26 KiB
C
/*
|
|
* Copyright (c) Microsoft Corporation
|
|
*
|
|
* Module Name :
|
|
* utils.c
|
|
*
|
|
* Contains all the work needed to present the console
|
|
*
|
|
*
|
|
* Sadagopan Rajaram -- Dec 20, 1999
|
|
*
|
|
*/
|
|
|
|
#include "tcadmin.h"
|
|
|
|
BOOL AnsiStatus = (sizeof(TCHAR) == sizeof(CHAR));
|
|
|
|
|
|
BOOL
|
|
Browse(
|
|
)
|
|
{
|
|
int index,j;
|
|
LONG retVal;
|
|
DWORD len;
|
|
TCHAR name[MAX_BUFFER_SIZE];
|
|
LPTSTR message[NUMBER_FIELDS + 1];
|
|
TCHAR device[MAX_BUFFER_SIZE];
|
|
int nameLen, deviceLen;
|
|
UINT baudRate;
|
|
LPTSTR temp;
|
|
UCHAR stopBits, parity, wordLen;
|
|
BOOL cont = TRUE;
|
|
TCHAR key;
|
|
LPTSTR confirm;
|
|
BOOL readRet;
|
|
|
|
for(index = 0; index < NUMBER_FIELDS; index ++){
|
|
message[index] = RetreiveMessageText(MSG_NAME_PROMPT+index);
|
|
if (!message[index]) {
|
|
for(j=index-1; j>=0;j--){
|
|
TCFree(message[j]);
|
|
}
|
|
_tprintf(_T("Cannot find Resources\n"));
|
|
return FALSE;
|
|
}
|
|
temp = message[index];
|
|
while(*temp != _T('%')){
|
|
temp++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
}
|
|
message[index] = RetreiveMessageText(MSG_NAME_PROMPT+index);
|
|
if (!message[index]) {
|
|
for(j=index-1; j>=0;j--){
|
|
TCFree(message[j]);
|
|
}
|
|
_tprintf(_T("Cannot find Resources\n"));
|
|
index ++;
|
|
return FALSE;
|
|
}
|
|
confirm = RetreiveMessageText(MSG_CONFIRM_PROMPT);
|
|
if (!confirm) {
|
|
for(j=index-1; j>=0;j--){
|
|
TCFree(message[j]);
|
|
}
|
|
_tprintf(_T("Cannot find Resources\n"));
|
|
index ++;
|
|
return FALSE;
|
|
}
|
|
confirm[_tcslen(confirm) - 2] = _T('\0');
|
|
index = 0;
|
|
do{
|
|
parity = NO_PARITY;
|
|
baudRate = DEFAULT_BAUD_RATE;
|
|
stopBits = 0;
|
|
wordLen = 8;
|
|
nameLen = deviceLen =MAX_BUFFER_SIZE;
|
|
name[0] = device[0] = (TCHAR) 0;
|
|
retVal = (LONG) (getparams)(index,
|
|
name,
|
|
&nameLen,
|
|
device,
|
|
&deviceLen,
|
|
&stopBits,
|
|
&parity,
|
|
&baudRate,
|
|
&wordLen
|
|
);
|
|
if(retVal != ERROR_SUCCESS){
|
|
if (retVal == ERROR_NO_MORE_ITEMS){
|
|
index --;
|
|
if(index < 0 ) {
|
|
cont=FALSE;
|
|
continue;
|
|
}
|
|
goto input;
|
|
}
|
|
else{
|
|
_tprintf(_T("%d\n"),retVal);
|
|
cont=FALSE;
|
|
}
|
|
continue;
|
|
}
|
|
DisplayParameters(message,
|
|
name,
|
|
device,
|
|
baudRate,
|
|
wordLen,
|
|
parity,
|
|
stopBits
|
|
);
|
|
_tprintf(_T("%s"),message[6]);
|
|
input:
|
|
readRet = ReadFile(hConsoleInput,
|
|
&key,
|
|
sizeof(TCHAR),
|
|
&len,
|
|
NULL
|
|
);
|
|
if(!readRet || !len){
|
|
exit(1);
|
|
}
|
|
if(lastChar == _T('\r') && key == _T('\n')){
|
|
lastChar = key;
|
|
goto input;
|
|
}
|
|
|
|
lastChar = key;
|
|
switch(key){
|
|
case _T('p'):
|
|
case _T('P'):
|
|
if(index == 0){
|
|
goto input;
|
|
}
|
|
index --;
|
|
break;
|
|
case _T('n'):
|
|
case _T('N'):
|
|
index ++;
|
|
break;
|
|
case _T('m'):
|
|
case _T('M'):
|
|
cont=FALSE;
|
|
break;
|
|
case _T('d'):
|
|
case _T('D'):
|
|
retVal = (LONG) (deletekey)(name);
|
|
if(index > 0){
|
|
index --;
|
|
}
|
|
break;
|
|
case _T('e'):
|
|
case _T('E'):
|
|
retVal = DisplayEditMenu(name,
|
|
_tcslen(name),
|
|
device,
|
|
_tcslen(device),
|
|
&baudRate,
|
|
&wordLen,
|
|
&parity,
|
|
&stopBits
|
|
);
|
|
|
|
if(retVal == ERROR_SUCCESS){
|
|
DisplayParameters(message,
|
|
name,
|
|
device,
|
|
baudRate,
|
|
wordLen,
|
|
parity,
|
|
stopBits
|
|
);
|
|
_tprintf(_T("%s"),confirm);
|
|
do{
|
|
readRet = ReadFile(hConsoleInput,
|
|
&key,
|
|
sizeof(TCHAR),
|
|
&len,
|
|
NULL
|
|
);
|
|
if(!readRet || !len){
|
|
exit(1);
|
|
}
|
|
if(lastChar != _T('\r') || key != _T('\n')){
|
|
lastChar = key;
|
|
break;
|
|
}
|
|
lastChar = key;
|
|
}while(1);
|
|
|
|
if((key == _T('y'))
|
|
|| (key == _T('Y'))){
|
|
retVal = (LONG) (setparams)(name,
|
|
device,
|
|
&stopBits,
|
|
&parity,
|
|
&baudRate,
|
|
&wordLen
|
|
);
|
|
if(retVal != ERROR_SUCCESS){
|
|
temp = RetreiveMessageText(MSG_ERROR_SET);
|
|
temp[_tcslen(temp) - 2 ] = _T('\0');
|
|
if(temp){
|
|
_tprintf(_T("%s %d"),temp,retVal);
|
|
}
|
|
TCFree(temp);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
goto input;
|
|
}
|
|
|
|
}while(cont);
|
|
|
|
for(index = 0; index <= NUMBER_FIELDS; index ++){
|
|
TCFree(message[index]);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID DisplayScreen(
|
|
UINT MessageID
|
|
)
|
|
{
|
|
LPTSTR Message;
|
|
DWORD len;
|
|
|
|
Message = RetreiveMessageText(MessageID);
|
|
if (!Message) {
|
|
_tprintf(_T("Cannot retreive message\n"));
|
|
return;
|
|
}
|
|
_tprintf(_T("%s"),Message);
|
|
TCFree(Message);
|
|
return;
|
|
}
|
|
|
|
int
|
|
DisplayEditMenu(
|
|
TCHAR *name,
|
|
int nameLen,
|
|
TCHAR *device,
|
|
int deviceLen,
|
|
UINT *BaudRate,
|
|
UCHAR *WordLen,
|
|
UCHAR *Parity,
|
|
UCHAR *StopBits
|
|
)
|
|
{
|
|
|
|
|
|
LPTSTR message,temp,curr;
|
|
int i;
|
|
DWORD len;
|
|
BOOL ret;
|
|
TCHAR buffer[MAX_BUFFER_SIZE];
|
|
int dat;
|
|
|
|
message = RetreiveMessageText(MSG_NAME_PROMPT);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),message);
|
|
TCFree(message);
|
|
while(!GetLine(name, nameLen, MAX_BUFFER_SIZE));
|
|
message = RetreiveMessageText(MSG_DEVICE_PROMPT);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),message);
|
|
TCFree(message);
|
|
while(!GetLine(device, deviceLen, MAX_BUFFER_SIZE));
|
|
message = RetreiveMessageText(MSG_BAUD_PROMPT);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),message);
|
|
TCFree(message);
|
|
_stprintf(buffer,_T("%d"),*BaudRate);
|
|
while(!GetLine(buffer,_tcslen(buffer) , MAX_BUFFER_SIZE));
|
|
_stscanf(buffer,_T("%d"),BaudRate);
|
|
message = RetreiveMessageText(MSG_WORD_PROMPT);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),message);
|
|
TCFree(message);
|
|
_stprintf(buffer,_T("%d"),*WordLen);
|
|
while(!GetLine(buffer,_tcslen(buffer) , MAX_BUFFER_SIZE));
|
|
_stscanf(buffer,_T("%d"),&dat);
|
|
*WordLen = (UCHAR) dat;
|
|
message = RetreiveMessageText(MSG_PARITY_PROMPT2);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = curr = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,NO_PARITY);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,ODD_PARITY);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,EVEN_PARITY);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,MARK_PARITY);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,SPACE_PARITY);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),curr);
|
|
TCFree(message);
|
|
_stprintf(buffer,_T("%d"),*Parity);
|
|
while(!GetLine(buffer,_tcslen(buffer) , MAX_BUFFER_SIZE));
|
|
_stscanf(buffer,_T("%d"),&dat);
|
|
*Parity = (UCHAR) dat;
|
|
message = RetreiveMessageText(MSG_STOP_PROMPT2);
|
|
if(! message){
|
|
return -1;
|
|
}
|
|
temp = curr = message;
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,STOP_BIT_1);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,STOP_BITS_1_5);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s%d"),curr,STOP_BITS_2);
|
|
curr = &(temp[1]);
|
|
while(*temp != _T('%')){
|
|
temp ++;
|
|
}
|
|
*temp = (TCHAR) 0;
|
|
_tprintf(_T("%s"),curr);
|
|
TCFree(message);
|
|
_stprintf(buffer,_T("%d"),*StopBits);
|
|
while(!GetLine(buffer,_tcslen(buffer) , MAX_BUFFER_SIZE));
|
|
_stscanf(buffer,_T("%d"),&dat);
|
|
*StopBits = (UCHAR) dat;
|
|
|
|
return ERROR_SUCCESS;
|
|
|
|
}
|
|
|
|
LPTSTR
|
|
RetreiveMessageText(
|
|
IN ULONG MessageId
|
|
)
|
|
{
|
|
ULONG LenBytes;
|
|
PMESSAGE_RESOURCE_ENTRY MessageEntry;
|
|
BOOLEAN IsUnicode;
|
|
ANSI_STRING AnsiString;
|
|
UNICODE_STRING UnicodeString;
|
|
NTSTATUS Status;
|
|
LPTSTR MessageText;
|
|
|
|
Status = RtlFindMessage(
|
|
ResourceImageBase,
|
|
(ULONG)(ULONG_PTR)RT_MESSAGETABLE,
|
|
0,
|
|
MessageId,
|
|
&MessageEntry
|
|
);
|
|
|
|
if(!NT_SUCCESS(Status)) {
|
|
_tprintf(_T("TCADMIN: Can't find message 0x%lx\n"),MessageId);
|
|
return(NULL);
|
|
}
|
|
|
|
IsUnicode = (BOOLEAN)((MessageEntry->Flags &
|
|
MESSAGE_RESOURCE_UNICODE) != 0);
|
|
|
|
//
|
|
// Get the size in bytes of a buffer large enough to hold the
|
|
// message and its terminating nul wchar. If the message is
|
|
// unicode, then this value is equal to the size of the message.
|
|
// If the message is not unicode, then we have to calculate this value.
|
|
//
|
|
if(IsUnicode) {
|
|
#ifdef UNICODE
|
|
LenBytes = (wcslen((PWSTR)MessageEntry->Text)
|
|
+ 1)*sizeof(WCHAR);
|
|
#else
|
|
LenBytes = wcstombs(NULL,(PWSTR)MessageEntry->Text, 0);
|
|
#endif
|
|
} else {
|
|
|
|
//
|
|
// RtlAnsiStringToUnicodeSize includes an implied wide-nul terminator
|
|
// in the count it returns.
|
|
//
|
|
#ifdef UNICODE
|
|
AnsiString.Buffer = MessageEntry->Text;
|
|
AnsiString.Length = (USHORT)strlen(MessageEntry->Text);
|
|
AnsiString.MaximumLength = AnsiString.Length;
|
|
|
|
LenBytes = RtlAnsiStringToUnicodeSize(&AnsiString);
|
|
#else
|
|
LenBytes = strlen((PCHAR) MessageEntry->Text);
|
|
#endif
|
|
}
|
|
|
|
LenBytes += sizeof(TCHAR);
|
|
//
|
|
// allocate a buffer.
|
|
//
|
|
MessageText = (LPTSTR) TCAlloc(LenBytes);
|
|
if(MessageText == NULL) {
|
|
return(NULL);
|
|
}
|
|
memset(MessageText,0,LenBytes);
|
|
if(IsUnicode) {
|
|
|
|
//
|
|
// Message is already unicode; just copy it into the buffer.
|
|
//
|
|
#ifdef UNICODE
|
|
wcscpy(MessageText,(PWSTR)MessageEntry->Text);
|
|
#else
|
|
LenBytes = wcstombs((PCHAR) MessageText,
|
|
(PWCHAR) MessageEntry->Text,
|
|
LenBytes);
|
|
#endif
|
|
|
|
} else {
|
|
|
|
//
|
|
// Message is not unicode; convert in into the buffer.
|
|
//
|
|
#ifdef UNICODE
|
|
UnicodeString.Buffer = MessageText;
|
|
UnicodeString.Length = 0;
|
|
UnicodeString.MaximumLength = (USHORT)LenBytes;
|
|
|
|
RtlAnsiStringToUnicodeString(&UnicodeString,
|
|
&AnsiString,
|
|
FALSE
|
|
);
|
|
#else
|
|
strcpy((PCHAR) MessageText, (PCHAR) MessageEntry->Text);
|
|
#endif
|
|
}
|
|
|
|
return(MessageText);
|
|
}
|
|
|
|
LONG
|
|
GetLine(
|
|
LPTSTR str,
|
|
int index,
|
|
int MaxLength
|
|
)
|
|
{
|
|
DWORD len;
|
|
DWORD size;
|
|
TCHAR buffer[3];
|
|
BOOL ret;
|
|
|
|
str[index] = (TCHAR) 0;
|
|
FlushConsoleInputBuffer(hConsoleInput);
|
|
_tprintf(_T("%s"),str);
|
|
buffer[0] = buffer[2] = (TCHAR) 0x8;
|
|
buffer[1] = (TCHAR) 0;
|
|
do{
|
|
if (index == MaxLength) {
|
|
index--;
|
|
}
|
|
|
|
//
|
|
// Read a (possibly) partial command line.
|
|
//
|
|
do{
|
|
ret = ReadFile(hConsoleInput,
|
|
&(str[index]),
|
|
sizeof(TCHAR),
|
|
&len,
|
|
NULL
|
|
);
|
|
if(!ret || !len){
|
|
exit(1);
|
|
}
|
|
if(lastChar != _T('\r') || str[index] != _T('\n')){
|
|
//ignore \r\n combinations
|
|
lastChar = str[index];
|
|
break;
|
|
}
|
|
lastChar = str[index];
|
|
}while(1);
|
|
|
|
lastChar = str[index];
|
|
if ((str[index] == (TCHAR) 0x8) || // backspace (^h)
|
|
(str[index] == (TCHAR) 0x7F)) { // delete
|
|
if (index > 0) {
|
|
WriteConsole(hConsoleOutput,
|
|
buffer,
|
|
3,
|
|
&len,
|
|
NULL
|
|
);
|
|
index--;
|
|
}
|
|
} else {
|
|
WriteConsole(hConsoleOutput,
|
|
&(str[index]),
|
|
1,
|
|
&len,
|
|
NULL
|
|
);
|
|
index++;
|
|
}
|
|
} while ((index == 0) || ((str[index - 1] != _T('\n')) &&(str[index-1] != _T('\r'))));
|
|
|
|
if(str[index-1] == _T('\r')){
|
|
buffer[0] = '\n';
|
|
str[index - 1] = '\0';
|
|
}
|
|
else{
|
|
buffer[0] = _T('\r');
|
|
str[index-1] ='\0';
|
|
}
|
|
|
|
WriteConsole(hConsoleOutput,
|
|
buffer,
|
|
1,
|
|
&len,
|
|
NULL
|
|
);
|
|
FlushConsoleInputBuffer(hConsoleInput);
|
|
return index;
|
|
}
|
|
|
|
VOID
|
|
DisplayParameters(
|
|
LPCTSTR *message,
|
|
LPCTSTR name,
|
|
LPCTSTR device,
|
|
UINT baudRate,
|
|
UCHAR wordLen,
|
|
UCHAR parity,
|
|
UCHAR stopBits
|
|
)
|
|
{
|
|
_tprintf(_T("%s "),message[0]);
|
|
_tprintf(_T("%s\n"),name);
|
|
_tprintf(_T("%s "),message[1]);
|
|
_tprintf(_T("%s\n"),device);
|
|
_tprintf(_T("%s "),message[2]);
|
|
_tprintf(_T("%d\n"),baudRate);
|
|
_tprintf(_T("%s "),message[3]);
|
|
_tprintf(_T("%d\n"),wordLen);
|
|
_tprintf(_T("%s "),message[4]);
|
|
switch(parity){
|
|
case NO_PARITY:
|
|
_tprintf(_T("NONE\n"));
|
|
break;
|
|
case ODD_PARITY:
|
|
_tprintf(_T("ODD\n"));
|
|
break;
|
|
case EVEN_PARITY:
|
|
_tprintf(_T("EVEN\n"));
|
|
break;
|
|
case MARK_PARITY:
|
|
_tprintf(_T("MARK\n"));
|
|
break;
|
|
case SPACE_PARITY:
|
|
_tprintf(_T("SPACE\n"));
|
|
break;
|
|
default:
|
|
_tprintf(_T("NONE\n"));
|
|
break;
|
|
}
|
|
_tprintf(_T("%s "),message[5]);
|
|
switch(stopBits){
|
|
case STOP_BIT_1:
|
|
_tprintf(_T("1\n"));
|
|
break;
|
|
case STOP_BITS_1_5:
|
|
_tprintf(_T("1.5\n"));
|
|
break;
|
|
case STOP_BITS_2:
|
|
_tprintf(_T("2\n"));
|
|
break;
|
|
default:
|
|
_tprintf(_T("1\n"));
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
VOID SendParameterChange(
|
|
)
|
|
{
|
|
SC_HANDLE sc_handle;
|
|
SC_HANDLE tc_handle;
|
|
LPTSTR temp;
|
|
BOOL ret;
|
|
SERVICE_STATUS status;
|
|
|
|
sc_handle = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_READ
|
|
);
|
|
if (sc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE_MANAGER);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s"), temp);
|
|
return;
|
|
}
|
|
}
|
|
tc_handle = OpenService(sc_handle,
|
|
TCSERV_NAME,
|
|
SERVICE_ALL_ACCESS
|
|
);
|
|
|
|
if (tc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp,GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
ret = ControlService(tc_handle,
|
|
SERVICE_CONTROL_PARAMCHANGE,
|
|
&status
|
|
);
|
|
if(ret == FALSE){
|
|
temp = RetreiveMessageText(CANNOT_SEND_PARAMETER_CHANGE);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp, GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
temp = RetreiveMessageText(SUCCESSFULLY_SENT_PARAMETER_CHANGE);
|
|
if(temp){
|
|
_tprintf(_T("%s"), temp);
|
|
TCFree(temp);
|
|
}
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
|
|
}
|
|
|
|
VOID
|
|
GetStatus(
|
|
)
|
|
{
|
|
SC_HANDLE sc_handle;
|
|
SC_HANDLE tc_handle;
|
|
DWORD len;
|
|
int i;
|
|
LPTSTR temp;
|
|
BOOL ret;
|
|
SERVICE_STATUS_PROCESS status;
|
|
DWORD val[] = {
|
|
SERVICE_STOPPED,
|
|
SERVICE_START_PENDING,
|
|
SERVICE_STOP_PENDING,
|
|
SERVICE_RUNNING,
|
|
SERVICE_CONTINUE_PENDING,
|
|
SERVICE_PAUSE_PENDING,
|
|
SERVICE_PAUSED
|
|
};
|
|
|
|
sc_handle = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_READ
|
|
);
|
|
if (sc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE_MANAGER);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s"), temp);
|
|
return;
|
|
}
|
|
}
|
|
tc_handle = OpenService(sc_handle,
|
|
TCSERV_NAME,
|
|
SERVICE_ALL_ACCESS
|
|
);
|
|
|
|
if (tc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp,GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
ret = QueryServiceStatusEx(tc_handle,
|
|
SC_STATUS_PROCESS_INFO,
|
|
(LPBYTE) &status,
|
|
sizeof(status),
|
|
&len
|
|
);
|
|
if(ret == FALSE){
|
|
temp = RetreiveMessageText(CANNOT_QUERY_STATUS);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp, GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
temp = RetreiveMessageText(QUERY_STATUS_SUCCESS);
|
|
if(temp){
|
|
temp[_tcslen(temp) -2 ] = (TCHAR) 0;
|
|
_tprintf(_T("%s"), temp);
|
|
TCFree(temp);
|
|
for(i = 0 ; i<NUMBER_OF_STATES; i++){
|
|
if(val[i] == status.dwCurrentState) break;
|
|
}
|
|
temp = RetreiveMessageText(SERVICE_STOPPED_MESSAGE + i);
|
|
if(temp){
|
|
_tprintf(_T("%s"),temp);
|
|
TCFree(temp);
|
|
}
|
|
|
|
}
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
|
|
}
|
|
|
|
VOID StopTCService(
|
|
)
|
|
{
|
|
SC_HANDLE sc_handle;
|
|
SC_HANDLE tc_handle;
|
|
LPTSTR temp;
|
|
BOOL ret;
|
|
SERVICE_STATUS status;
|
|
|
|
sc_handle = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_READ
|
|
);
|
|
if (sc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE_MANAGER);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s"), temp);
|
|
return;
|
|
}
|
|
}
|
|
tc_handle = OpenService(sc_handle,
|
|
TCSERV_NAME,
|
|
SERVICE_ALL_ACCESS
|
|
);
|
|
|
|
if (tc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp,GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
ret = ControlService(tc_handle,
|
|
SERVICE_CONTROL_STOP,
|
|
&status
|
|
);
|
|
if(ret == FALSE){
|
|
temp = RetreiveMessageText(CANNOT_SEND_STOP);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp, GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
temp = RetreiveMessageText(SUCCESSFULLY_SENT_STOP);
|
|
if(temp){
|
|
_tprintf(_T("%s"), temp);
|
|
TCFree(temp);
|
|
}
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
|
|
}
|
|
|
|
VOID StartTCService(
|
|
)
|
|
{
|
|
SC_HANDLE sc_handle;
|
|
SC_HANDLE tc_handle;
|
|
LPTSTR temp;
|
|
BOOL ret;
|
|
SERVICE_STATUS status;
|
|
|
|
sc_handle = OpenSCManager(NULL,
|
|
NULL,
|
|
GENERIC_READ
|
|
);
|
|
if (sc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE_MANAGER);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s"), temp);
|
|
return;
|
|
}
|
|
}
|
|
tc_handle = OpenService(sc_handle,
|
|
TCSERV_NAME,
|
|
SERVICE_ALL_ACCESS
|
|
);
|
|
|
|
if (tc_handle == NULL){
|
|
temp = RetreiveMessageText(CANNOT_OPEN_SERVICE);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp,GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
ret = StartService(tc_handle,
|
|
0,
|
|
NULL
|
|
);
|
|
if(ret == FALSE){
|
|
temp = RetreiveMessageText(CANNOT_SEND_START);
|
|
if(temp){
|
|
temp[_tcslen(temp) - 2] = (TCHAR) 0;
|
|
_tprintf(_T("%s %d"), temp, GetLastError());
|
|
TCFree(temp);
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
}
|
|
}
|
|
temp = RetreiveMessageText(SUCCESSFULLY_SENT_START);
|
|
if(temp){
|
|
_tprintf(_T("%s"), temp);
|
|
TCFree(temp);
|
|
}
|
|
CloseServiceHandle(tc_handle);
|
|
CloseServiceHandle(sc_handle);
|
|
return;
|
|
|
|
}
|
|
|
|
VOID
|
|
AddAllComPorts(
|
|
)
|
|
/*
|
|
* Adds all the Com ports in the system as parameters to bridge
|
|
* Reads key HKEY_LOCAL_MACHINE\HARDWARE\DEVICEMAP\SERIALCOMM
|
|
* Each value name is a com device name. The friendly name is the
|
|
* value data
|
|
*
|
|
*/
|
|
{
|
|
DWORD index;
|
|
HKEY m_hkey;
|
|
ULONG retVal;
|
|
LPTSTR temp;
|
|
TCHAR device[MAX_BUFFER_SIZE*2];
|
|
TCHAR name[MAX_BUFFER_SIZE];
|
|
UINT baudRate;
|
|
DWORD type;
|
|
DWORD deviceLen,nameLen;
|
|
UCHAR stopBits, parity, wordLen;
|
|
|
|
index = 0;
|
|
|
|
retVal = RegOpenKey(HKEY_LOCAL_MACHINE,
|
|
SERIAL_DEVICE_KEY,
|
|
&m_hkey
|
|
);
|
|
if(retVal != ERROR_SUCCESS){
|
|
_tprintf(_T("%d\n"),retVal);
|
|
return;
|
|
}
|
|
|
|
index = 0;
|
|
while(1){
|
|
deviceLen = nameLen = MAX_BUFFER_SIZE;
|
|
retVal = RegEnumValue(m_hkey,
|
|
index,
|
|
device,
|
|
&deviceLen,
|
|
NULL,
|
|
&type,
|
|
name,
|
|
&nameLen
|
|
);
|
|
if(retVal != ERROR_SUCCESS){
|
|
if(retVal != ERROR_NO_MORE_ITEMS){
|
|
_tprintf(_T("%d\n"),retVal);
|
|
}
|
|
break;
|
|
}
|
|
stopBits = STOP_BIT_1;
|
|
parity = NO_PARITY;
|
|
baudRate = DEFAULT_BAUD_RATE;
|
|
wordLen = SERIAL_DATABITS_8;
|
|
_stprintf(device, "\\??\\%s",name);
|
|
retVal = (ULONG) (setparams)(name,
|
|
device,
|
|
&stopBits,
|
|
&parity,
|
|
&baudRate,
|
|
&wordLen
|
|
);
|
|
if(retVal != ERROR_SUCCESS){
|
|
temp = RetreiveMessageText(MSG_ERROR_SET);
|
|
temp[_tcslen(temp) - 2 ] = _T('\0');
|
|
if(temp){
|
|
_tprintf(_T("%s %d"),temp,retVal);
|
|
}
|
|
TCFree(temp);
|
|
break;
|
|
}
|
|
index ++;
|
|
|
|
}
|
|
retVal = RegCloseKey(m_hkey);
|
|
|
|
|
|
|
|
|
|
}
|