// обмен данными с сервером в формате XML
// nCom - номер команды
// sPar1
// nTOutRead - таймаут на ожидание ответа от сервера
public string ExchgSrv(string nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret, int nTOutRead, int nBufSize)
{
string
sOutFileXML = "",
sC,
sHost,
sAdr,
sErr;
int
nPort;
SocketStream.ASRWERROR
nRErr;
System.IO.Stream
stm = null;
ret = AppC.RC_CANCEL;
ServerRet = AppC.EMPTY_INT;
if (xMF.xCLoad != null)
{
xMF.xCLoad.xLastSE = this;
xMF.xCLoad.sFileFromSrv = "";
}
SelSrvPort(nCom, sPar1, out sHost, out nPort);
sAdr = sHost + ":" + nPort.ToString();
sErr = sAdr + "-нет соединения!";
Cursor.Current = Cursors.WaitCursor;
try
{
CurSocket = new SocketStream(sHost, nPort);
if (!TestConn(false, xMF.xBCScanner, xMF.xFPan))
{
TraiceWiFi(sErr);
//throw new System.Net.Sockets.SocketException(11053);
}
else
{
//MessageBox.Show("Good reset!");
}
//TraiceWiFi(nCom + " - перед Connect");
stm = CurSocket.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команда не отправлена";
byte[] baCom = SetCommand2Srv(nCom, sPar1, sDop);
//stm.Write(baCom, 0, baCom.Length);
//stm.Write(AppC.baTermCom, 0, AppC.baTermCom.Length);
// 20 секунд на запись команды
CurSocket.ASWriteS.TimeOutWrite = 1000 * 10;
CurSocket.ASWriteS.BeginAWrite(baCom, baCom.Length);
if ((dsTrans != null) || (XMLPars != null))
{// передача данных при выгрузке
//sErr = sAdr + "-ошибка выгрузки";
//dsTrans.WriteXml(stm, XmlWriteMode.IgnoreSchema);
//sErr = sAdr + "-ошибка завершения";
sErr = sAdr + "-ошибка выгрузки";
MemoryStream mst = new MemoryStream();
if (dsTrans != null)
{
dsTrans.WriteXml(mst, XmlWriteMode.IgnoreSchema);
}
if (XMLPars != null)
{
mst.Write(XMLPars, 0, XMLPars.Length);
}
// терминатор сообщения
mst.Write(AppC.baTermMsg, 0, AppC.baTermMsg.Length);
byte[] bm1 = mst.ToArray();
mst.Close();
// 60 секунд на запись данных
CurSocket.ASWriteS.TimeOutWrite = 1000 * 180;
CurSocket.ASWriteS.BeginAWrite(bm1, bm1.Length);
}
else
{
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
CurSocket.ASWriteS.TimeOutWrite = 1000 * 30;
// терминатор сообщения
CurSocket.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
}
//int nCommLen = 0;
//byte[] bAns = ReadAnswerCommand(stm, ref nCommLen);
//sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
sErr = sAdr + "-нет ответа сервера!";
// 120 секунд на чтение ответа
//m_ssExchg.ASReadS.TimeOutRead = 1000 * 120;
//m_ssExchg.ASReadS.BufSize = 256;
//nRErr = m_ssExchg.ASReadS.BeginARead(bUseFileAsBuf, 1000 * nTOutRead);
if (nBufSize > 0)
{
CurSocket.ASReadS.BufSize = nBufSize;
}
nRErr = CurSocket.ASReadS.BeginARead(1000 * nTOutRead);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
sErr = " длинная команда";
throw new System.Net.Sockets.SocketException(10061);
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
sC = CurSocket.ASReadS.GetMsg();
break;
default:
TraiceWiFi("Сетевая ошибка (чтение ответа)");
throw new System.Net.Sockets.SocketException(10061);
}
sErr = sAdr + "-ошибка чтения";
//Dictionary<string, string> aComm = SrvCommandParse(sC);
ServerAnswer = Srv.SrvAnswerParParse(sC);
SyncTimeWithSrv();
if (ServerAnswer.ContainsKey("PAR"))
{
StringAnsPars = ServerAnswer["PAR"];
StringAnsPars = StringAnsPars.Substring(1, StringAnsPars.Length - 2);
AnswerPars = Srv.SrvAnswerParParse(StringAnsPars, new char[] { ',' });
}
//TraiceWiFi("Ответ получен...");
ServerRet = int.Parse(ServerAnswer["RET"]);
if ((ServerAnswer["COM"] == nCom) &&
((ServerRet == AppC.RC_OK) ||
(ServerRet == AppC.RC_NEEDPARS) ||
(ServerRet == AppC.RC_HALFOK)))
{
CurSocket.ASReadS.OutFile = "";
if (ServerRet == AppC.RC_NEEDPARS)
{
CurSocket.ASReadS.TermDat = AppC.baTermMsg;
if (CurSocket.ASReadS.BeginARead(true, 1000 * nTOutRead) == SocketStream.ASRWERROR.RET_FULLMSG)
{
//TraiceWiFi("Доп.Данные получены...");
sOutFileXML = CurSocket.ASReadS.OutFile;
}
else
{
TraiceWiFi("Сетевая ошибка (чтение данных)");
throw new System.Net.Sockets.SocketException(10061);
}
}
if (dgRead != null)
{
dgRead(CurSocket, ServerAnswer, dsTrans, ref sErr, ServerRet);
}
try
{
sErr = ServerAnswer["MSG"];
}
catch { sErr = "OK"; }
//dgRead(m_ssExchg, aComm, dsTrans, ref sErr, nRetSrv);
//else
//{
// sErr = "OK";
//}
}
else
{
if (ServerAnswer["MSG"] != "")
{
sErr = ServerAnswer["MSG"];
}
else
{
sErr = sAdr + "\n Отложено выполнение";
}
}
ret = ServerRet;
}
catch (Exception e)
{
//sC = e.Message;
sErr = e.Message;
TraiceWiFi(sErr);
ret = 3;
}
finally
{
CurSocket.Disconnect();
Cursor.Current = Cursors.Default;
if (ServerRet == AppC.RC_NEEDPARS)
{
if (Srv.ExchangeContext.ExchgReason == AppC.EXCHG_RSN.NO_EXCHG)
{
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.SRV_INIT;
Srv.ExchangeContext.CMD_EXCHG = nCom;
DialogResult xDRslt = xMF.CallDllForm(xMF.sExeDir + "SGPF-Univ.dll", true,
new object[] { this, nCom, AppC.R_PARS, sOutFileXML });
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.NO_EXCHG;
if (xDRslt == DialogResult.OK)
{
}
}
}
}
return(sErr);
}
private void NsiFromSrv(SocketStream stmX, Dictionary <string, string> aC, DataSet ds,
ref string sErr, int nRetSrv)
{
int
nFullEnd = 0,
nStartRead = 0,
nEndRead = 0;
string
sMD5New = aC["MD5"],
sP = xNSI.sPathNSI + xNSI.DT[sTName].sXML;
SocketStream.ASRWERROR
nRErr;
if ((bMD_5 == true) && (sMD5New == (string)xNSI.BD_TINF_RW(sTName)["MD5"]))
{
sErr = "OK-No Load";
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
else
{
sErr = "Ошибка чтения XML";
string sXMLFile = "";
if (stmX.ASReadS.OutFile.Length == 0)
{
stmX.ASReadS.TermDat = AppC.baTermMsg;
nStartRead = Environment.TickCount;
nRErr = stmX.ASReadS.BeginARead(true, 1000 * 300);
nEndRead = Environment.TickCount;
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
}
sXMLFile = stmX.ASReadS.OutFile;
stmX.Disconnect();
try
{
xNSI.DT[sTName].dt.BeginLoadData();
xNSI.DT[sTName].dt.Clear();
System.Xml.XmlReader xmlRd = System.Xml.XmlReader.Create(sXMLFile);
xNSI.DT[sTName].dt.ReadXml(xmlRd);
xmlRd.Close();
xNSI.DT[sTName].dt.EndLoadData();
if (File.Exists(sP))
{
File.Delete(sP);
}
if (xNSI.AfterLoadNSI(sTName, true, sXMLFile) == AppC.RC_OK)
{
File.Move(sXMLFile, sP);
}
xNSI.BD_TINF_RW(sTName)["MD5"] = sMD5New;
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
finally
{
if (File.Exists(sXMLFile))
{// возникла ошибка при загрузке, иначе отработал бы Move
sErr = "Ошибка загрузки XML";
File.Delete(sXMLFile);
}
else
{// ошибок не было
sErr = "OK";
}
nFullEnd = Environment.TickCount;
//xNSI.DT[sTName].sDTStat = String.Format("{0(сокет)}-{1(XML)}-{2(Full)}",
// Srv.TimeDiff(nStartRead, nEndRead, 1),
// Srv.TimeDiff(nEndRead, nFullEnd, 1),
// Srv.TimeDiff(xNSI.DT[sTName].nCount, nFullEnd, 1));
xNSI.DT[sTName].sDTStat = String.Format("{0}(сокет)-{1}(XML)-{2}(Full)",
Srv.TimeDiff(nStartRead, nEndRead, 1),
Srv.TimeDiff(nEndRead, nFullEnd, 1),
Srv.TimeDiff(xNSI.DT[sTName].nCount, nFullEnd, 1));
}
}
}
private string ExchgSrv(int nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret)
{
string sC;
string sAdr = xPars.sHostSrv + ":" + xPars.nSrvPort.ToString();
string sErr = sAdr + "-нет связи с сервером";
int nRetSrv;
byte[] bAns = { };
//SocketStream.ASRWERROR nRErr;
System.IO.Stream stm = null;
ret = 0;
try
{
ssWrite = new SocketStream(xPars.sHostSrv, xPars.nSrvPort);
if (!TestConnection())
{
//throw new System.Net.Sockets.SocketException(11053);
}
stm = ssWrite.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команды не отправлена";
byte[] baCom = SetUpLoadCommand(nCom, sPar1, sDop);
// 20 секунд на запись команды
ssWrite.ASWriteS.TimeOutWrite = 1000 * 20;
ssWrite.ASWriteS.BeginAWrite(baCom, baCom.Length);
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
ssWrite.ASWriteS.TimeOutWrite = 1000 * 10;
// терминатор сообщения
ssWrite.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
sErr = sAdr + "-ошибка чтения";
/*
* // 120 секунд на чтение ответа
* ssWrite.ASReadS.TimeOutRead = 1000 * 120;
* ssWrite.ASReadS.TermMsg = AppC.baTermCom;
* nRErr = ssWrite.ASReadS.BeginARead();
* switch (nRErr)
* {
* case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
* sErr = " длинная команда";
* throw new System.Net.Sockets.SocketException(10061);
* case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
* sC = ssWrite.ASReadS.GetMsg();
* break;
* default:
* throw new System.Net.Sockets.SocketException(10061);
* }
*/
//============
int nCommLen = 0;
bAns = ReadAnswerCommand(stm, ref nCommLen);
sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
//================
Dictionary <string, string> aComm = SrvCommParse(sC, new char[] { ';' });
nRetSrv = int.Parse(aComm["RET"]);
if (aComm["COM"] == AppC.saComms[nCom])
{
if (nRetSrv == AppC.RC_OK)
{
sErr = "OK";
if (dgRead != null)
{
dgRead(stm, aComm, dsTrans, ref sErr, nRetSrv);
}
else
{//
//sErr = sAdr + "-завершение";
//// 5 секунд на чтение ответа
//ssWrite.ASReadS.TimeOutRead = 1000 * 5;
//ssWrite.ASReadS.TermMsg = AppC.baTermMsg;
//nRErr = ssWrite.ASReadS.BeginARead(256);
//switch (nRErr)
//{
// case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
// sErr = " длинная команда";
// throw new System.Net.Sockets.SocketException(10061);
// case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
// break;
// default:
// throw new System.Net.Sockets.SocketException(10061);
//}
}
}
else
{
if (aComm["MSG"] != "")
{
sErr = sAdr + " - ошибка:\r\n" + aComm["MSG"];
}
else
{
sErr = sAdr + "\r\n Отложено выполнение";
}
}
}
ret = nRetSrv;
}
catch (Exception e)
{
sC = e.Message;
ret = 3;
}
finally
{
ssWrite.Disconnect();
}
return(sErr);
}
private string ShMove(string sHostSh, int nPortSh, string sLogin, string sPass,
string sDevID, string sOper, ref int nRet)
{
string sC;
string sAdr = sHostSh + ":" + nPortSh.ToString();
string sErr = sAdr + "-нет связи с сервером";
SocketStream.ASRWERROR nRErr;
byte[] baCom;
SocketStream ssSH = null;
System.IO.Stream stm = null;
try
{
Encoding enc866 = Encoding.Default;
ssSH = new SocketStream(sHostSh, nPortSh);
if (!TestConnection())
{
//throw new System.Net.Sockets.SocketException(11053);
}
stm = ssSH.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команда не отправлена";
string sCom = "100|" + sLogin + "|" + sPass + "|" + sDevID + "|" + sOper;
baCom = enc866.GetBytes(sCom);
// 10 секунд на запись команды
ssSH.ASWriteS.TimeOutWrite = 1000 * 10;
ssSH.ASWriteS.BeginAWrite(baCom, baCom.Length);
sErr = sAdr + "-ошибка чтения";
// 20 секунд на чтение ответа
ssSH.ASReadS.TimeOutRead = 1000 * 30;
ssSH.ASReadS.MsgEncoding = Encoding.Default;
//ssSH.ASReadS.TermMsg = enc866.GetBytes("1|");
ssSH.ASReadS.TermDat = enc866.GetBytes("1|");
nRErr = ssSH.ASReadS.BeginARead(256);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
sErr = " длинная команда";
throw new System.Net.Sockets.SocketException(10061);
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
sC = ssSH.ASReadS.GetMsg();
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
sErr = " ошибочный ответ";
string[] saReply = sC.Split(new char[] { '|' });
nRet = int.Parse(saReply[2]);
switch (nRet)
{
case 0:
sErr = "OK";
break;
case -1:
sErr = " Неверный ID";
break;
case -2:
sErr = " Неверный User/Pass";
break;
case -3:
sErr = " Ошибка устройства";
break;
case -4:
sErr = " Нет прав";
break;
default:
sErr = " Неизвестная ошибка";
break;
}
}
catch (Exception e)
{
sC = e.Message;
nRet = 3;
}
finally
{
ssSH.Disconnect();
}
return(sErr);
}
private void NsiFromSrv(SocketStream stmX, Dictionary <string, string> aC, DataSet ds,
ref string sErr, int nRetSrv)
{
SocketStream.ASRWERROR nRErr;
string sMD5New = aC["MD5"];
string sP = xNSI.sPathNSI + xNSI.DT[sTName].sXML;
if ((bMD_5 == true) && (sMD5New == (string)xNSI.BD_TINF_RW(sTName)["MD5"]))
{
sErr = "OK-No Load";
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
else
{
sErr = "Ошибка чтения XML";
string sXMLFile = "";
if (stmX.ASReadS.OutFile.Length == 0)
{
stmX.ASReadS.TermDat = AppC.baTermMsg;
nRErr = stmX.ASReadS.BeginARead(true, 1000 * 60);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
break;
default:
throw new System.Net.Sockets.SocketException(10061);
}
}
sXMLFile = stmX.ASReadS.OutFile;
stmX.Disconnect();
try
{
sErr = "Ошибка загрузки XML";
xNSI.DT[sTName].dt.BeginLoadData();
xNSI.DT[sTName].dt.Clear();
System.Xml.XmlReader xmlRd = System.Xml.XmlReader.Create(sXMLFile);
xNSI.DT[sTName].dt.ReadXml(xmlRd);
xmlRd.Close();
xNSI.DT[sTName].dt.EndLoadData();
sErr = "Ошибка сохранения XML";
if (File.Exists(sP))
{
File.Delete(sP);
}
if (xNSI.AfterLoadNSI(sTName, true, sXMLFile) == AppC.RC_OK)
{
File.Move(sXMLFile, sP);
}
xNSI.BD_TINF_RW(sTName)["MD5"] = sMD5New;
xNSI.BD_TINF_RW(sTName)["LASTLOAD"] = DateTime.Now;
}
finally
{
if (File.Exists(sXMLFile))
{// возникла ошибка при загрузке, иначе отработал бы Move
sErr = "Ошибка загрузки XML";
File.Delete(sXMLFile);
}
else
{// ошибок не было
sErr = "OK";
}
}
}
}
