[1146] | 1 | using System;
|
---|
| 2 | using System.Diagnostics;
|
---|
| 3 | using System.Text;
|
---|
| 4 | using System.IO;
|
---|
| 5 | using System.Net.Sockets;
|
---|
| 6 | using System.Net;
|
---|
| 7 | using System.Security.Cryptography;
|
---|
| 8 | using System.Security.Permissions;
|
---|
| 9 | using System.Security.Principal;
|
---|
| 10 | using System.Threading;
|
---|
| 11 | using System.Timers;
|
---|
[1193] | 12 | using System.Linq;
|
---|
[1146] | 13 |
|
---|
| 14 | namespace IndianHealthService.BMXNet.Net
|
---|
| 15 | {
|
---|
| 16 | /// <summary>
|
---|
| 17 | /// BMXNetBroker implements low-level socket connectivity to RPMS databases.
|
---|
| 18 | /// The VA RPC Broker must be running on the RPMS server in order for
|
---|
| 19 | /// BMXNetBroker to connect.
|
---|
| 20 | /// </summary>
|
---|
| 21 | [DnsPermission(SecurityAction.Assert, Unrestricted = true)]
|
---|
| 22 | internal class BMXNetSessionSocketConnection : BMXNetSessionConnection
|
---|
| 23 | {
|
---|
| 24 | public static int DefaultSendTimeout = 20000;
|
---|
| 25 | public static int DefaultReceiveTimeout = 40000;
|
---|
| 26 |
|
---|
[1180] | 27 |
|
---|
[1146] | 28 | private int _sendTimeout = 0;
|
---|
| 29 |
|
---|
| 30 | public override int SendTimeout
|
---|
| 31 | {
|
---|
| 32 | get
|
---|
| 33 | {
|
---|
| 34 | if (_sendTimeout != 0)
|
---|
| 35 | {
|
---|
| 36 | return _sendTimeout;
|
---|
| 37 | }
|
---|
| 38 | return this.ConnectionSpec.SendTimeout == 0 ? DefaultSendTimeout : this.ConnectionSpec.SendTimeout;
|
---|
| 39 | }
|
---|
| 40 | set { _sendTimeout = value; }
|
---|
| 41 | }
|
---|
| 42 |
|
---|
| 43 |
|
---|
| 44 | private int _receiveTimeout = 0;
|
---|
| 45 |
|
---|
| 46 | /// <summary>
|
---|
| 47 | /// Set and retrieve the timeout, in milliseconds, to receive a response from the RPMS server.
|
---|
| 48 | /// If the retrieve time exceeds the timeout, an exception will be thrown and the connection will be closed.
|
---|
| 49 | /// The default is 30 seconds.
|
---|
| 50 | /// </summary>
|
---|
| 51 | public override int ReceiveTimeout
|
---|
| 52 | {
|
---|
| 53 | get
|
---|
| 54 | {
|
---|
| 55 | if (_receiveTimeout != 0)
|
---|
| 56 | {
|
---|
| 57 | return _receiveTimeout;
|
---|
| 58 | }
|
---|
| 59 | return this.ConnectionSpec.ReceiveTimeout == 0 ? DefaultReceiveTimeout : this.ConnectionSpec.ReceiveTimeout;
|
---|
| 60 | }
|
---|
| 61 | set
|
---|
| 62 | {
|
---|
| 63 | _receiveTimeout = value;
|
---|
| 64 | }
|
---|
| 65 | }
|
---|
| 66 |
|
---|
[1180] | 67 | public override Encoding ConnectionEncoding // Default Encoding determined by Windows; typically a Windows Code Page
|
---|
| 68 | {
|
---|
| 69 | get;
|
---|
| 70 | set;
|
---|
| 71 | }
|
---|
| 72 |
|
---|
| 73 |
|
---|
[1146] | 74 | public BMXNetSessionSocketConnection(BMXNetBroker aBroker):base(aBroker)
|
---|
| 75 | {
|
---|
| 76 | m_sWKID = "BMX";
|
---|
| 77 | m_sWINH = "";
|
---|
| 78 | m_sPRCH = "";
|
---|
| 79 | m_sWISH = "";
|
---|
| 80 | m_cHDR = ADEBHDR(m_sWKID,m_sWINH,m_sPRCH,m_sWISH);
|
---|
| 81 |
|
---|
[1180] | 82 | ConnectionEncoding = Encoding.Default;
|
---|
| 83 |
|
---|
[1146] | 84 | }
|
---|
| 85 |
|
---|
| 86 |
|
---|
| 87 |
|
---|
| 88 | #region RPX Fields
|
---|
| 89 |
|
---|
| 90 | private string m_sWKID;
|
---|
| 91 | private string m_sWISH;
|
---|
| 92 | private string m_sPRCH;
|
---|
| 93 | private string m_sWINH;
|
---|
| 94 | private string m_cHDR;
|
---|
| 95 | private bool m_bConnected;
|
---|
| 96 | private TcpClient m_pCommSocket;
|
---|
| 97 | private string m_sNameSpace = "";
|
---|
| 98 |
|
---|
| 99 | #endregion RPX Fields
|
---|
| 100 |
|
---|
| 101 |
|
---|
| 102 | public TcpClient Socket
|
---|
| 103 | {
|
---|
| 104 | get { return this.m_pCommSocket; }
|
---|
| 105 | }
|
---|
| 106 |
|
---|
| 107 | /// <summary>
|
---|
| 108 | /// Returns index of first instance of sSubString in sString.
|
---|
| 109 | /// If sSubString not found, returns -1.
|
---|
| 110 | /// </summary>
|
---|
| 111 | /// <returns></returns>
|
---|
| 112 |
|
---|
| 113 | [SocketPermissionAttribute(SecurityAction.Assert,
|
---|
| 114 | Access = "Connect",
|
---|
| 115 | Host = "All",
|
---|
| 116 | Port = "All",
|
---|
| 117 | Transport = "All")]
|
---|
[1193] | 118 | protected virtual void OpenConnectionCommon()
|
---|
[1146] | 119 | {
|
---|
| 120 | try
|
---|
| 121 | {
|
---|
| 122 | TcpClient connector = null;
|
---|
| 123 |
|
---|
| 124 | try
|
---|
| 125 | {
|
---|
| 126 | connector = new TcpClient();
|
---|
| 127 | connector.SendTimeout = this.SendTimeout;
|
---|
| 128 | connector.ReceiveTimeout = this.ReceiveTimeout;
|
---|
| 129 | connector.Connect(this.ServerAddress, this.ServerPort);
|
---|
| 130 | }
|
---|
| 131 | catch (SocketException exSocket)
|
---|
| 132 | {
|
---|
| 133 | string s = exSocket.Message + exSocket.StackTrace;
|
---|
| 134 | throw new BMXNetException(s);
|
---|
| 135 | }
|
---|
| 136 |
|
---|
| 137 | //Prepare & send the connect message
|
---|
| 138 | string cSend = "TCPconnect^" + m_sNameSpace + "^^";
|
---|
| 139 | int nLen = cSend.Length;
|
---|
| 140 | string sLen = nLen.ToString();
|
---|
| 141 | sLen = sLen.PadLeft(5, '0');
|
---|
| 142 | cSend = "{BMX}" + sLen + cSend;
|
---|
| 143 |
|
---|
| 144 | NetworkStream ns = connector.GetStream();
|
---|
| 145 | byte[] sendBytes = Encoding.ASCII.GetBytes(cSend);
|
---|
| 146 | ns.Write(sendBytes,0,sendBytes.Length);
|
---|
| 147 |
|
---|
| 148 | m_pCommSocket = connector;
|
---|
| 149 | return;
|
---|
| 150 |
|
---|
| 151 | }
|
---|
| 152 | catch (BMXNetException bmxEx)
|
---|
| 153 | {
|
---|
| 154 | throw bmxEx;
|
---|
| 155 | }
|
---|
| 156 | catch (Exception ex)
|
---|
| 157 | {
|
---|
| 158 | string s = ex.Message + ex.StackTrace;
|
---|
| 159 | throw new BMXNetException(s);
|
---|
| 160 | }
|
---|
| 161 | }//End OpenConnectionCommon
|
---|
| 162 |
|
---|
| 163 |
|
---|
| 164 | private BMXNetSocketConnectionSpec _connectionSpec = null;
|
---|
| 165 |
|
---|
| 166 | internal BMXNetSocketConnectionSpec ConnectionSpec
|
---|
| 167 | {
|
---|
| 168 | get { return _connectionSpec; }
|
---|
| 169 | set { _connectionSpec = value; }
|
---|
| 170 | }
|
---|
| 171 |
|
---|
| 172 |
|
---|
| 173 | [SocketPermissionAttribute(SecurityAction.Assert,
|
---|
| 174 | Access = "Connect",
|
---|
| 175 | Host = "All",
|
---|
| 176 | Port = "All",
|
---|
| 177 | Transport = "All")]
|
---|
| 178 | public virtual bool OpenConnection(BMXNetSocketConnectionSpec aSpec)
|
---|
| 179 | {
|
---|
| 180 | this.ConnectionSpec = aSpec;
|
---|
| 181 |
|
---|
| 182 | try
|
---|
| 183 | {
|
---|
| 184 | m_bConnected = false;
|
---|
| 185 | this.OpenConnectionCommon();
|
---|
| 186 | if (this.CheckConnection())
|
---|
| 187 | {
|
---|
| 188 | bool authenicated = false;
|
---|
| 189 |
|
---|
| 190 | if (aSpec.UseWindowsAuthentication)
|
---|
| 191 | {
|
---|
| 192 | authenicated = this.SendSecurityRequest(aSpec.WindowsIdentity);
|
---|
| 193 | }
|
---|
| 194 | else
|
---|
| 195 | {
|
---|
| 196 | authenicated = SendSecurityRequest(aSpec.EncryptedAccessVerifyCode);
|
---|
| 197 | }
|
---|
| 198 |
|
---|
| 199 | this.m_bConnected = authenicated;
|
---|
| 200 |
|
---|
| 201 |
|
---|
| 202 |
|
---|
| 203 | int integerDuz = 0;
|
---|
| 204 | if (!int.TryParse(this.DUZ, out integerDuz))
|
---|
| 205 | {
|
---|
| 206 | throw new BMXNetException("Invalid DUZ, Unable to authenticate user.");
|
---|
| 207 | }
|
---|
| 208 |
|
---|
| 209 | this.UserName = this.GetUserName();
|
---|
| 210 | }
|
---|
| 211 | return this.IsConnected;
|
---|
| 212 | }
|
---|
| 213 | catch (BMXNetException bmxEx)
|
---|
| 214 | {
|
---|
| 215 | throw bmxEx;
|
---|
| 216 | }
|
---|
| 217 | catch (Exception ex)
|
---|
| 218 | {
|
---|
| 219 | string s = ex.Message + ex.StackTrace;
|
---|
| 220 | throw new BMXNetException(s);
|
---|
| 221 | }
|
---|
| 222 | finally
|
---|
| 223 | {
|
---|
| 224 | if (!this.IsConnected)
|
---|
| 225 | {
|
---|
| 226 | this.PrimitiveCloseConnection();
|
---|
| 227 | }
|
---|
| 228 | }
|
---|
| 229 | }
|
---|
| 230 |
|
---|
| 231 | bool m_bLogging = false;
|
---|
| 232 |
|
---|
| 233 | private static void Log(String logMessage, TextWriter w)
|
---|
| 234 | {
|
---|
| 235 | w.WriteLine("{0} {1}", DateTime.Now.ToLongTimeString(),
|
---|
| 236 | DateTime.Now.ToLongDateString());
|
---|
| 237 | w.WriteLine(" :");
|
---|
| 238 | w.WriteLine(" :{0}", logMessage);
|
---|
| 239 | w.WriteLine("-------------------------------");
|
---|
| 240 | // Update the underlying file.
|
---|
| 241 | w.Flush();
|
---|
| 242 | }
|
---|
| 243 |
|
---|
| 244 | private bool CheckConnection()
|
---|
| 245 | {
|
---|
| 246 | try
|
---|
| 247 | {
|
---|
| 248 | String cMSG = ADEBLDMsg(m_cHDR, "BMX CONNECT STATUS", "");
|
---|
[1180] | 249 | #if DEBUG
|
---|
| 250 | _watch = new Stopwatch();
|
---|
| 251 | _watch.Start();
|
---|
| 252 | #endif
|
---|
[1146] | 253 | this.SendString(this.Socket, cMSG);
|
---|
| 254 | String strReceive = ReceiveString(this.Socket);
|
---|
[1180] | 255 | #if DEBUG
|
---|
| 256 | _watch.Stop();
|
---|
| 257 |
|
---|
| 258 | Debug.WriteLine("Time: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 259 | Debug.WriteLine("---");
|
---|
| 260 | _watch = null;
|
---|
| 261 | #endif
|
---|
| 262 |
|
---|
[1146] | 263 | String port = BMXNetBroker.Piece(strReceive, "|", 1);
|
---|
| 264 | String message = BMXNetBroker.Piece(strReceive, "|", 2);
|
---|
| 265 |
|
---|
| 266 | if (!message.Contains("OK"))
|
---|
| 267 | {
|
---|
| 268 | throw new BMXNetException(message.Length==0 ? strReceive : message);
|
---|
| 269 | }
|
---|
| 270 |
|
---|
| 271 | this.Job = BMXNetBroker.Piece(strReceive, "|", 3);
|
---|
| 272 |
|
---|
| 273 | return true;
|
---|
| 274 | }
|
---|
| 275 | catch (Exception potentialProblem)
|
---|
| 276 | { //If there's an issue, assume old BMX 2.x/3.x so this feature is not supports BMX CONNECT STATUS
|
---|
| 277 | if (potentialProblem.Message.Contains("BMX CONNECT STATUS"))
|
---|
| 278 | {
|
---|
| 279 | return true;
|
---|
| 280 | }
|
---|
| 281 | else
|
---|
| 282 | {
|
---|
| 283 | throw potentialProblem;
|
---|
| 284 | }
|
---|
| 285 | }
|
---|
| 286 | }
|
---|
| 287 |
|
---|
| 288 | public override bool IsConnected
|
---|
| 289 | {
|
---|
| 290 | get
|
---|
| 291 | {
|
---|
| 292 | return this.m_bConnected;
|
---|
| 293 | }
|
---|
| 294 | }
|
---|
| 295 |
|
---|
[1180] | 296 | Stopwatch _watch = new Stopwatch();
|
---|
| 297 |
|
---|
[1146] | 298 | protected override String SendReceiveString(string cSendString, string cMult)
|
---|
| 299 | {
|
---|
| 300 | #if DEBUG
|
---|
[1180] | 301 | _watch = new Stopwatch();
|
---|
[1146] | 302 | _watch.Start();
|
---|
| 303 | #endif
|
---|
| 304 | this.SendString(this.m_pCommSocket, cSendString, cMult);
|
---|
[1180] | 305 | Debug.WriteLine("Time After Send: " + _watch.ElapsedMilliseconds + " ms");
|
---|
[1146] | 306 | string _received = this.ReceiveString(this.m_pCommSocket);
|
---|
| 307 | #if DEBUG
|
---|
[1180] | 308 | _watch.Stop();
|
---|
| 309 |
|
---|
[1146] | 310 | Debug.WriteLine("Time: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 311 | Debug.WriteLine("---");
|
---|
| 312 | _watch = null;
|
---|
| 313 | #endif
|
---|
| 314 | return _received;
|
---|
| 315 | }
|
---|
| 316 |
|
---|
| 317 |
|
---|
| 318 | protected virtual void SendString(TcpClient tcpClient, string cSendString)
|
---|
| 319 | {
|
---|
| 320 | string sMult = "";
|
---|
| 321 | SendString(tcpClient, cSendString, sMult);
|
---|
| 322 | }
|
---|
| 323 |
|
---|
| 324 | protected virtual void SendString(TcpClient tcpClient, string cSendString, string cMult)
|
---|
| 325 | {
|
---|
[1180] | 326 | #if DEBUG
|
---|
| 327 | Debug.WriteLine("Sending (T:" + Thread.CurrentThread.ManagedThreadId + "): " + cSendString);
|
---|
| 328 | #endif
|
---|
[1146] | 329 | String encodedString = this.EncodeSendString(cSendString, cMult);
|
---|
| 330 |
|
---|
| 331 | NetworkStream ns = tcpClient.GetStream();
|
---|
| 332 | ns.WriteTimeout = this.SendTimeout;
|
---|
[1180] | 333 | byte[] sendBytes = ConnectionEncoding.GetBytes(encodedString);
|
---|
[1146] | 334 | ns.Write(sendBytes,0,sendBytes.Length);
|
---|
| 335 | if (this.m_bLogging == true)
|
---|
| 336 | {
|
---|
| 337 | Log("Sent: " + cSendString, this.m_LogWriter);
|
---|
| 338 | }
|
---|
| 339 | return;
|
---|
| 340 | }
|
---|
| 341 |
|
---|
| 342 |
|
---|
| 343 | private string ReceiveString(TcpClient tcpClient)
|
---|
| 344 | {
|
---|
[1180] | 345 | #if DEBUG
|
---|
| 346 | Debug.WriteLine("Time At Start of Receive: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 347 | #endif
|
---|
| 348 |
|
---|
[1193] | 349 | /******************INIT*****************/
|
---|
[1180] | 350 | NetworkStream ns = tcpClient.GetStream();
|
---|
| 351 | ns.ReadTimeout = this.ReceiveTimeout; //Timeout; throw exception automatically if we time out.
|
---|
| 352 |
|
---|
[1193] | 353 | /*************SECURITY S-PACKET READ***********************/
|
---|
| 354 | int secPackLen = ns.ReadByte(); //Read S-Pack Length Byte
|
---|
| 355 | byte[] secPackContents = new byte[secPackLen];;
|
---|
| 356 | if (secPackLen > 0)
|
---|
| 357 | {
|
---|
| 358 | ns.Read(secPackContents, 0, secPackLen);
|
---|
| 359 | }
|
---|
| 360 |
|
---|
| 361 | /****************ERROR S-PACKET READ******************/
|
---|
| 362 | int errPackLen = ns.ReadByte(); //Read S-Pack Length Byte
|
---|
| 363 | byte[] errPackConents = new byte[errPackLen];;
|
---|
| 364 | if (errPackLen > 0)
|
---|
| 365 | {
|
---|
| 366 | ns.Read(errPackConents, 0, errPackLen);
|
---|
| 367 | }
|
---|
| 368 |
|
---|
| 369 | //If either one of these exists, then we have an error on the Mumps Database
|
---|
| 370 | if (secPackLen > 0 || errPackLen > 0)
|
---|
| 371 | {
|
---|
| 372 | //We still have to read the Data to empty the tcp OS buffers even if we have security/errors in the DB
|
---|
| 373 | while (ns.DataAvailable) ns.ReadByte() ; //while loop to empty the buffer -- this is theoretically slow, but that's not important here
|
---|
| 374 |
|
---|
| 375 | //Now decode them.
|
---|
| 376 | string secString = ConnectionEncoding.GetString(secPackContents);
|
---|
| 377 | string errString = ConnectionEncoding.GetString(errPackConents);
|
---|
| 378 | throw new BMXNetException("Mumps Database Security/Error: " + secString + " | " + errString);
|
---|
| 379 | }
|
---|
| 380 |
|
---|
| 381 | /*****************DATA STREAM READ*******************/
|
---|
| 382 | //Data stream from VISTA ends when we find the EOT (ASCII 4) character
|
---|
[1180] | 383 | MemoryStream mStream = new MemoryStream(1500); // Auto expanding memory storage for what we receive
|
---|
[1193] | 384 | int numberOfBytesRead = 0;
|
---|
[1180] | 385 | bool bFinished = false; // Have we found the End of Transmission (ASCII 4) yet?
|
---|
| 386 |
|
---|
| 387 | // Main Read Loop
|
---|
| 388 | while (!bFinished) //while we are not done
|
---|
| 389 | {
|
---|
| 390 | byte[] bReadBuffer = new byte[1500]; //buffer size = MTU. Message MUST be smaller.
|
---|
| 391 | numberOfBytesRead = ns.Read(bReadBuffer, 0, bReadBuffer.Length); //read data
|
---|
| 392 | bFinished = FindChar(bReadBuffer, (char)4) > -1; //look for the EOT (ASCII 4) character
|
---|
| 393 | if (!bFinished) mStream.Write(bReadBuffer, 0, numberOfBytesRead); //if we are not done, put the whole stream in
|
---|
| 394 | else mStream.Write(bReadBuffer, 0, numberOfBytesRead - 1); //otherwise, number of bytes minus the $C(4) at the end
|
---|
| 395 | }
|
---|
[1193] | 396 |
|
---|
| 397 | //At this point, we are done reading from the Network Stream. Now we have to decode the data.
|
---|
[1180] | 398 |
|
---|
[1193] | 399 | //Decode the entire message.
|
---|
| 400 | string sReadBuffer = ConnectionEncoding.GetString(mStream.ToArray()); //decode
|
---|
[1180] | 401 |
|
---|
| 402 | String decodedReceiveString = this.DecodeReceiveString(sReadBuffer);
|
---|
| 403 |
|
---|
| 404 | if (this.m_bLogging)
|
---|
| 405 | {
|
---|
| 406 | Log("Received: " + decodedReceiveString, this.m_LogWriter);
|
---|
| 407 | }
|
---|
| 408 | #if DEBUG
|
---|
| 409 | Debug.WriteLine("Time At End of Receive: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 410 | Debug.WriteLine("Received(T:" + Thread.CurrentThread.ManagedThreadId + "): " + decodedReceiveString.Replace((char)30, (char)10));
|
---|
| 411 | #endif
|
---|
| 412 | return decodedReceiveString;
|
---|
| 413 |
|
---|
| 414 |
|
---|
| 415 | /* OLD CODE
|
---|
| 416 | NetworkStream ns = tcpClient.GetStream();
|
---|
[1146] | 417 | ns.ReadTimeout = this.ReceiveTimeout;
|
---|
| 418 |
|
---|
| 419 |
|
---|
| 420 | //TAE: This following is suspect. NetworkSTream Read and ReadTimeout provide
|
---|
| 421 | //the same behavior. Look at removing in the futuer. For now, this works.
|
---|
| 422 | int cyclePause = 25;
|
---|
| 423 | int cycles = 0;
|
---|
| 424 | DateTime start = DateTime.Now;
|
---|
| 425 | while (ns.DataAvailable == false)
|
---|
| 426 | {
|
---|
| 427 | if (cycles++ > 999)
|
---|
| 428 | break;
|
---|
| 429 | if ((DateTime.Now-start).TotalMilliseconds > this.ReceiveTimeout)
|
---|
| 430 | break;
|
---|
| 431 | Thread.Sleep(cyclePause);
|
---|
| 432 | }
|
---|
| 433 |
|
---|
| 434 | Debug.Assert(ns.DataAvailable);
|
---|
| 435 | if (!ns.DataAvailable)
|
---|
| 436 | {
|
---|
| 437 | this.Close();
|
---|
| 438 | throw new Exception("BMXNetBroker.ReceiveString timeout. Connection Closed.");
|
---|
| 439 | }
|
---|
| 440 |
|
---|
| 441 | byte[] bReadBuffer = new byte[1024];
|
---|
| 442 | string sReadBuffer = "";
|
---|
| 443 | StringBuilder sbAll = new StringBuilder("", 1024);
|
---|
| 444 | int numberOfBytesRead = 0;
|
---|
| 445 |
|
---|
| 446 | // Incoming message may be larger than the buffer size.
|
---|
| 447 |
|
---|
| 448 | bool bFinished = false;
|
---|
| 449 | bool bStarted = false;
|
---|
| 450 | int lpBuf = 0;
|
---|
| 451 | string sError = "";
|
---|
| 452 | string sAppError = "";
|
---|
| 453 | do
|
---|
| 454 | {
|
---|
| 455 |
|
---|
| 456 | numberOfBytesRead = ns.Read(bReadBuffer, 0, bReadBuffer.Length);
|
---|
| 457 | if ((numberOfBytesRead == 1)&&(bStarted == false))
|
---|
| 458 | {
|
---|
| 459 | //TAE: This following is suspect. If Read is blocking then this sleep is extra.
|
---|
| 460 | //This is rarely called
|
---|
| 461 | Thread.Sleep(15);
|
---|
| 462 | numberOfBytesRead += ns.Read(bReadBuffer,1, bReadBuffer.Length-1);
|
---|
| 463 | }
|
---|
| 464 | if (bStarted == false)
|
---|
| 465 | {
|
---|
| 466 | //Process error info at beginning of returned string
|
---|
| 467 | int nErrLen = bReadBuffer[0];
|
---|
| 468 | int nAppLen = bReadBuffer[bReadBuffer[0]+1];
|
---|
| 469 | if ((bReadBuffer[2] == 0)&&(bReadBuffer[3] == 0))
|
---|
| 470 | { //special case: M error trap invoked in SND^XWBTCPC
|
---|
| 471 | lpBuf += 2;
|
---|
| 472 | }
|
---|
| 473 | sError = Encoding.ASCII.GetString(bReadBuffer, lpBuf + 1, nErrLen);
|
---|
| 474 | if (sError != "")
|
---|
| 475 | {
|
---|
| 476 | sAppError = Encoding.ASCII.GetString(bReadBuffer, lpBuf + 1 + nErrLen + 1, nAppLen);
|
---|
| 477 | throw new BMXNetException(sError);
|
---|
| 478 | }
|
---|
| 479 | sAppError = Encoding.ASCII.GetString(bReadBuffer, lpBuf+1+nErrLen+1, nAppLen);
|
---|
| 480 | lpBuf += (nErrLen + nAppLen + 2);
|
---|
| 481 | numberOfBytesRead -= (nErrLen + nAppLen + 2);
|
---|
| 482 | bStarted = true;
|
---|
| 483 | }
|
---|
| 484 |
|
---|
| 485 | bFinished = FindChar(bReadBuffer, (char)4) > -1;
|
---|
| 486 | Debug.Assert(numberOfBytesRead > -1);
|
---|
| 487 | sReadBuffer = Encoding.ASCII.GetString(bReadBuffer, lpBuf, numberOfBytesRead);
|
---|
| 488 | lpBuf = 0;
|
---|
| 489 | if (bFinished)
|
---|
| 490 | {
|
---|
| 491 | sbAll.Append(sReadBuffer, 0, numberOfBytesRead -1);
|
---|
| 492 | }
|
---|
| 493 | else
|
---|
| 494 | {
|
---|
| 495 | sbAll.Append(sReadBuffer);
|
---|
| 496 | }
|
---|
| 497 | }
|
---|
| 498 | while(!bFinished);
|
---|
| 499 |
|
---|
| 500 | String decodedReceiveString = this.DecodeReceiveString(sbAll.ToString());
|
---|
| 501 |
|
---|
| 502 | if (this.m_bLogging)
|
---|
| 503 | {
|
---|
| 504 | Log("Received: " + decodedReceiveString, this.m_LogWriter);
|
---|
| 505 | }
|
---|
[1180] | 506 | #if DEBUG
|
---|
| 507 | Debug.WriteLine("Time At End of Receive: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 508 | #endif
|
---|
[1146] | 509 | return decodedReceiveString;
|
---|
[1180] | 510 | */
|
---|
[1146] | 511 | }
|
---|
| 512 |
|
---|
| 513 |
|
---|
| 514 | private bool SendSecurityRequest(WindowsIdentity winIdentity)
|
---|
| 515 | {
|
---|
| 516 | string strReceive = "";
|
---|
| 517 | string cMSG;
|
---|
| 518 | string sTest;
|
---|
| 519 |
|
---|
| 520 | //Build AV Call
|
---|
| 521 | cMSG = ADEBLDMsg(m_cHDR, "BMX AV CODE", winIdentity.Name);
|
---|
[1180] | 522 | #if DEBUG
|
---|
| 523 | _watch = new Stopwatch();
|
---|
| 524 | _watch.Start();
|
---|
| 525 | #endif
|
---|
[1146] | 526 | SendString(this.Socket, cMSG);
|
---|
[1180] | 527 | strReceive = ReceiveString(this.Socket);
|
---|
| 528 | #if DEBUG
|
---|
| 529 | _watch.Stop();
|
---|
[1146] | 530 |
|
---|
[1180] | 531 | Debug.WriteLine("Time: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 532 | Debug.WriteLine("---");
|
---|
| 533 | _watch = null;
|
---|
| 534 | #endif
|
---|
| 535 |
|
---|
[1146] | 536 | sTest = strReceive.Substring(0,3);
|
---|
| 537 |
|
---|
| 538 | char[] cDelim = {(char) 13,(char) 10,(char) 0};
|
---|
| 539 | string sDelim = new string(cDelim);
|
---|
| 540 | int nPiece = 1;
|
---|
| 541 | this.DUZ = M.Piece(strReceive, sDelim , nPiece);
|
---|
| 542 | if ((this.DUZ.Length==0 ) || ("0".Equals(this.DUZ)))
|
---|
| 543 | {
|
---|
| 544 | nPiece = 7;
|
---|
| 545 | string sReason = M.Piece(strReceive, sDelim, nPiece);
|
---|
| 546 | throw new Exception(sReason);
|
---|
| 547 | }
|
---|
| 548 |
|
---|
| 549 | return true;
|
---|
| 550 | }
|
---|
| 551 |
|
---|
| 552 | public String EncryptAccessVerifyCode(string anAccessCode, string aVerifyCode)
|
---|
| 553 | {
|
---|
| 554 | string accessVerifyPair = anAccessCode.ToUpper() + ";" + aVerifyCode.ToUpper();
|
---|
| 555 | return this.EncryptionProvider.Encrypt(accessVerifyPair);
|
---|
| 556 | }
|
---|
| 557 |
|
---|
| 558 | private bool SendSecurityRequest(string encryptedAccessVerifyCode)
|
---|
| 559 | {
|
---|
| 560 | string strReceive = "";
|
---|
| 561 | string cMSG;
|
---|
| 562 |
|
---|
| 563 | cMSG = ADEBLDMsg(m_cHDR, "XUS AV CODE", encryptedAccessVerifyCode);
|
---|
[1180] | 564 | #if DEBUG
|
---|
| 565 | _watch = new Stopwatch();
|
---|
| 566 | _watch.Start();
|
---|
| 567 | #endif
|
---|
[1146] | 568 | SendString(this.Socket, cMSG);
|
---|
| 569 | strReceive = ReceiveString(this.Socket);
|
---|
[1180] | 570 | #if DEBUG
|
---|
| 571 | _watch.Stop();
|
---|
[1146] | 572 |
|
---|
[1180] | 573 | Debug.WriteLine("Time: " + _watch.ElapsedMilliseconds + " ms");
|
---|
| 574 | Debug.WriteLine("---");
|
---|
| 575 | _watch = null;
|
---|
| 576 | #endif
|
---|
| 577 |
|
---|
[1146] | 578 | if (strReceive.StartsWith("M ERROR="))
|
---|
| 579 | {
|
---|
| 580 | this.DUZ = "0";
|
---|
| 581 | throw new BMXNetException("Server error has occured: " + strReceive);
|
---|
| 582 | }
|
---|
| 583 |
|
---|
| 584 |
|
---|
| 585 | char[] cDelim = {(char) 13,(char) 10,(char) 0};
|
---|
| 586 | string U = new string(cDelim);
|
---|
| 587 |
|
---|
| 588 | this.DUZ = M.Piece(strReceive,U, 1);
|
---|
| 589 | String resultCode = M.Piece(strReceive, U, 2);
|
---|
| 590 | String resultMessageIndex = M.Piece(strReceive, U, 3);
|
---|
| 591 | //R(0)=DUZ if sign-on was OK, zero if not OK.
|
---|
| 592 | //R(1)=(0=OK, 1,2...=Can't sign-on for some reason).
|
---|
| 593 | //R(2)=verify needs changing.
|
---|
| 594 | //R(3)=Message.
|
---|
| 595 | //R(4)=0
|
---|
| 596 | //R(5)=count of the number of lines of text, zero if none.
|
---|
| 597 |
|
---|
| 598 | //extracall but same code-path as winidentity login
|
---|
| 599 |
|
---|
| 600 | if ((this.DUZ == "0") || (this.DUZ == ""))
|
---|
| 601 | {
|
---|
| 602 | string sReason = M.Piece(strReceive, U, 7);
|
---|
| 603 | throw new BMXNetException(sReason);
|
---|
| 604 | }
|
---|
| 605 |
|
---|
| 606 | return true;
|
---|
| 607 | }
|
---|
| 608 |
|
---|
| 609 |
|
---|
| 610 | public override void Close()
|
---|
| 611 | {
|
---|
| 612 | if (m_bConnected)
|
---|
| 613 | {
|
---|
| 614 | this.PrimitiveCloseConnection();
|
---|
| 615 | }
|
---|
| 616 | }
|
---|
| 617 |
|
---|
| 618 | protected void PrimitiveCloseConnection() {
|
---|
| 619 |
|
---|
| 620 | if (this.Socket != null)
|
---|
| 621 | {
|
---|
| 622 | SendString(this.Socket, "#BYE#");
|
---|
| 623 | this.Socket.Close();
|
---|
| 624 | m_pCommSocket = null;
|
---|
| 625 | }
|
---|
| 626 | this.ConnectionSpec = null;
|
---|
| 627 | this.DUZ = "";
|
---|
| 628 | m_bConnected=false;
|
---|
| 629 | }
|
---|
| 630 |
|
---|
| 631 |
|
---|
| 632 | public override string GetLoginFacility(String aDuz)
|
---|
| 633 | {
|
---|
| 634 | try
|
---|
| 635 | {
|
---|
| 636 | if (!this.IsConnected)
|
---|
| 637 | {
|
---|
| 638 | throw new BMXNetException("BMXNetBroker is not connected to RPMS");
|
---|
| 639 | }
|
---|
[1180] | 640 | #if DEBUG
|
---|
| 641 | _watch = new Stopwatch();
|
---|
| 642 | _watch.Start();
|
---|
| 643 | #endif
|
---|
[1146] | 644 | this.SendString(this.Socket, ADEBLDMsg(m_cHDR, "BMXGetFac", aDuz));
|
---|
| 645 | return this.ReceiveString(this.Socket);
|
---|
| 646 | }
|
---|
| 647 | catch (BMXNetException bmxEx)
|
---|
| 648 | {
|
---|
| 649 | throw new BMXNetException(bmxEx.Message + " || "+bmxEx.StackTrace);
|
---|
| 650 | }
|
---|
| 651 | catch (Exception ex)
|
---|
| 652 | {
|
---|
| 653 | throw ex;
|
---|
| 654 | }
|
---|
| 655 | }
|
---|
| 656 |
|
---|
| 657 |
|
---|
| 658 | protected String GetUserName()
|
---|
| 659 | {
|
---|
| 660 | return this.TransmitRPC("BMX USER", this.DUZ);
|
---|
| 661 | }
|
---|
| 662 |
|
---|
| 663 | /// <summary>
|
---|
| 664 | /// Ping the server, will reset read-timeout
|
---|
| 665 | /// </summary>
|
---|
| 666 | /// <returns>Answer the #milliseconds to run or -1 if theres an issue</returns>
|
---|
| 667 | public double ImHereServer()
|
---|
| 668 | {
|
---|
| 669 | try
|
---|
| 670 | {
|
---|
| 671 | if (this.IsConnected)
|
---|
| 672 | {
|
---|
| 673 | DateTime past = DateTime.Now;
|
---|
| 674 | this.TransmitRPC("BMX IM HERE","");
|
---|
| 675 | return (DateTime.Now - past).TotalMilliseconds;
|
---|
| 676 | }
|
---|
| 677 | else
|
---|
| 678 | {
|
---|
| 679 | return -1;
|
---|
| 680 | }
|
---|
| 681 | }
|
---|
| 682 | catch
|
---|
| 683 | {
|
---|
| 684 | return -1;
|
---|
| 685 | }
|
---|
| 686 | }
|
---|
| 687 |
|
---|
| 688 | #region RPX Properties
|
---|
| 689 |
|
---|
| 690 |
|
---|
| 691 |
|
---|
| 692 | public bool Connected
|
---|
| 693 | {
|
---|
| 694 | get
|
---|
| 695 | {
|
---|
| 696 | return m_bConnected;
|
---|
| 697 | }
|
---|
| 698 | }
|
---|
| 699 |
|
---|
| 700 |
|
---|
| 701 | public string ServerAddress
|
---|
| 702 | {
|
---|
| 703 | get
|
---|
| 704 | {
|
---|
| 705 | return this.ConnectionSpec.Server;
|
---|
| 706 | }
|
---|
| 707 | }
|
---|
| 708 |
|
---|
| 709 | public string ServerNamespace
|
---|
| 710 | {
|
---|
| 711 | get
|
---|
| 712 | {
|
---|
| 713 | return this.ConnectionSpec.NameSpace;
|
---|
| 714 | }
|
---|
| 715 | }
|
---|
| 716 |
|
---|
| 717 | public int ServerPort
|
---|
| 718 | {
|
---|
| 719 | get
|
---|
| 720 | {
|
---|
| 721 | return this.ConnectionSpec.Port;
|
---|
| 722 | }
|
---|
| 723 | }
|
---|
| 724 |
|
---|
| 725 |
|
---|
| 726 | #endregion RPX Properties
|
---|
| 727 |
|
---|
| 728 |
|
---|
| 729 |
|
---|
| 730 |
|
---|
| 731 | }
|
---|
| 732 |
|
---|
| 733 | /*
|
---|
| 734 | 1 ;;1;Signons not currently allowed on this processor.
|
---|
| 735 | 2 ;;1;Maximum number of users already signed on to this processor.
|
---|
| 736 | 3 ;;1;This device has not been defined to the system -- contact system manager.
|
---|
| 737 | 4 ;;0;Not a valid Windows Identity map value.
|
---|
| 738 | 5 ;;0;No Access Allowed for this User.
|
---|
| 739 | 6 ;;0;Invalid device password.
|
---|
| 740 | 7 ;;0;Device locked due to too many invalid sign-on attempts.
|
---|
| 741 | 8 ;;1;This device is out of service.
|
---|
| 742 | 9 ;;0;*** MULTIPLE SIGN-ONS NOT ALLOWED ***
|
---|
| 743 | 10 ;;1;You don't have access to this device!
|
---|
| 744 | 11 ;;0;Your access code has been terminated. Please see your site manager!
|
---|
| 745 | 12 ;;0;VERIFY CODE MUST be changed before continued use.
|
---|
| 746 | 13 ;;1;This device may only be used outside of this time frame |
|
---|
| 747 | 14 ;;0;'|' is not a valid UCI!
|
---|
| 748 | 15 ;;0;'|' is not a valid program name!
|
---|
| 749 | 16 ;;0;No PRIMARY MENU assigned to user or User is missing KEY to menu!
|
---|
| 750 | 17 ;;0;Your access to the system is prohibited from |.
|
---|
| 751 | 18 ;;0;Windows Integrated Security Not Allowed on this port.*/
|
---|
| 752 | }
|
---|