Bits CNullModem::readChar() {
Bits rxchar = clientsocket->GetcharNonBlock();
if (telnet && rxchar>=0) return TelnetEmulation((Bit8u)rxchar);
else if (rxchar==0xff && !transparent) {// escape char
// get the next char
Bits rxchar = clientsocket->GetcharNonBlock();
if (rxchar==0xff) return rxchar; // 0xff 0xff -> 0xff was meant
rxchar&0x1? setCTS(true) : setCTS(false);
rxchar&0x2? setDSR(true) : setDSR(false);
if (rxchar&0x4) receiveByteEx(0x0,0x10);
return -1; // no "payload" received
} else return rxchar;
}
void CSerialDummy::setDTR(bool val) {
#ifdef CHECKIT_TESTPLUG
setDSR(val);
setRI(val);
setCD(val);
#endif
}
void CDirectSerial::updateMSR () {
int new_status = SERIAL_getmodemstatus(comport);
setCTS(new_status&SERIAL_CTS? true:false);
setDSR(new_status&SERIAL_DSR? true:false);
setRI(new_status&SERIAL_RI? true:false);
setCD(new_status&SERIAL_CD? true:false);
}
CSerialDummy::CSerialDummy(Bitu id, CommandLine* cmd):CSerial(id, cmd) {
CSerial::Init_Registers();
setRI(false);
setDSR(false);
setCD(false);
setCTS(false);
InstallationSuccessful=true;
}
CSerialLog::CSerialLog(Bitu id, CommandLine* cmd):CSerial(id, cmd) {
CSerial::Init_Registers();
// DSR+CTS on to make sure the DOS COM device will not get stuck waiting for them
setRI(false);
setCD(false);
setDSR(true);
setCTS(true);
InstallationSuccessful=true;
}
void CDirectSerial::updateMSR () {
DWORD dptr = 0;
if (!GetCommModemStatus (hCom, &dptr)) {
#ifdef SERIALPORT_DEBUGMSG
// LOG_MSG ("Serial port at %x: GetCommModemStatus failed!", base);
#endif
//return;
}
setCTS((dptr & MS_CTS_ON)!=0);
setDSR((dptr & MS_DSR_ON)!=0);
setRI ((dptr & MS_RING_ON)!=0);
setCD((dptr & MS_RLSD_ON)!=0);
}
void CNullModem::Disconnect() {
removeEvent(SERIAL_POLLING_EVENT);
removeEvent(SERIAL_RX_EVENT);
// it was disconnected; free the socket and restart the server socket
LOG_MSG("Serial%d: Disconnected.",COMNUMBER);
delete clientsocket;
clientsocket=0;
setDSR(false);
setCTS(false);
setCD(false);
if (serverport) {
serversocket = new TCPServerSocket(serverport);
if (serversocket->isopen)
setEvent(SERIAL_SERVER_POLLING_EVENT, 50);
else delete serversocket;
} else if (dtrrespect) {
setEvent(SERIAL_NULLMODEM_DTR_EVENT,50);
DTR_delta = getDTR(); // try to reconnect the next time DTR is set
}
}
void CSerialLog::setDTR(bool val) {
setDSR(val);
setRI(val);
setCD(val);
}
CNullModem::CNullModem(Bitu id, CommandLine* cmd):CSerial (id, cmd) {
Bitu temptcpport=23;
memset(&telClient, 0, sizeof(telClient));
InstallationSuccessful = false;
serversocket = 0;
clientsocket = 0;
serverport = 0;
clientport = 0;
rx_retry = 0;
rx_retry_max = 20;
rx_state=N_RX_DISC;
tx_gather = 12;
dtrrespect=false;
tx_block=false;
receiveblock=false;
transparent=false;
telnet=false;
Bitu bool_temp=0;
// usedtr: The nullmodem will
// 1) when it is client connect to the server not immediately but
// as soon as a modem-aware application is started (DTR is switched on).
// 2) only receive data when DTR is on.
if (getBituSubstring("usedtr:", &bool_temp, cmd)) {
if (bool_temp==1) {
dtrrespect=true;
transparent=true;
DTR_delta=false; // connect immediately when DTR is already 1
}
}
// transparent: don't add additional handshake control.
if (getBituSubstring("transparent:", &bool_temp, cmd)) {
if (bool_temp==1) transparent=true;
else transparent=false;
}
// telnet: interpret telnet commands.
if (getBituSubstring("telnet:", &bool_temp, cmd)) {
if (bool_temp==1) {
transparent=true;
telnet=true;
}
}
// rxdelay: How many milliseconds to wait before causing an
// overflow when the application is unresponsive.
if (getBituSubstring("rxdelay:", &rx_retry_max, cmd)) {
if (!(rx_retry_max<=10000)) {
rx_retry_max=50;
}
}
// txdelay: How many milliseconds to wait before sending data.
// This reduces network overhead quite a lot.
if (getBituSubstring("txdelay:", &tx_gather, cmd)) {
if (!(tx_gather<=500)) {
tx_gather=12;
}
}
// port is for both server and client
if (getBituSubstring("port:", &temptcpport, cmd)) {
if (!(temptcpport>0&&temptcpport<65536)) {
temptcpport=23;
}
}
// socket inheritance (client-alike)
if (getBituSubstring("inhsocket:", &bool_temp, cmd)) {
#ifdef NATIVESOCKETS
if (Netwrapper_GetCapabilities()&NETWRAPPER_TCP_NATIVESOCKET) {
if (bool_temp==1) {
int sock;
if (control->cmdline->FindInt("-socket",sock,true)) {
dtrrespect=false;
transparent=true;
LOG_MSG("Inheritance socket handle: %d",sock);
if (!ClientConnect(new TCPClientSocket(sock)))
return;
} else {
LOG_MSG("Serial%d: -socket parameter missing.",COMNUMBER);
return;
}
}
} else {
LOG_MSG("Serial%d: socket inheritance not supported on this platform.",
COMNUMBER);
return;
}
#else
LOG_MSG("Serial%d: socket inheritance not available.", COMNUMBER);
#endif
} else {
// normal server/client
std::string tmpstring;
if (cmd->FindStringBegin("server:",tmpstring,false)) {
// we are a client
const char* hostnamechar=tmpstring.c_str();
size_t hostlen=strlen(hostnamechar)+1;
if (hostlen>sizeof(hostnamebuffer)) {
hostlen=sizeof(hostnamebuffer);
hostnamebuffer[sizeof(hostnamebuffer)-1]=0;
}
memcpy(hostnamebuffer,hostnamechar,hostlen);
clientport=(Bit16u)temptcpport;
if (dtrrespect) {
// we connect as soon as DTR is switched on
setEvent(SERIAL_NULLMODEM_DTR_EVENT, 50);
LOG_MSG("Serial%d: Waiting for DTR...",COMNUMBER);
} else if (!ClientConnect(
new TCPClientSocket((char*)hostnamebuffer,(Bit16u)clientport)))
return;
} else {
// we are a server
serverport = (Bit16u)temptcpport;
if (!ServerListen()) return;
}
}
CSerial::Init_Registers();
InstallationSuccessful = true;
setCTS(dtrrespect||transparent);
setDSR(dtrrespect||transparent);
setRI(false);
setCD(clientsocket > 0); // CD on if connection established
}
