/// <summary>
/// 新增
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public bool Insert(T entity)
{
NET net = new NET();
net.Set <T>().Add(entity);
return(net.SaveChanges() > 0);
}
public static void SVC_RemoteCommand( )
{
Int32 i;
String remaining;
i = Rcon_Validate();
var msg = Lib.CtoJava(Globals.net_message.data, 4, 1024);
if (i == 0)
{
Com.Printf("Bad rcon from " + NET.AdrToString(Globals.net_from) + ":\\n" + msg + "\\n");
}
else
{
Com.Printf("Rcon from " + NET.AdrToString(Globals.net_from) + ":\\n" + msg + "\\n");
}
Com.BeginRedirect(Defines.RD_PACKET, SV_SEND.sv_outputbuf, Defines.SV_OUTPUTBUF_LENGTH, new AnonymousRD_Flusher());
if (0 == Rcon_Validate())
{
Com.Printf("Bad rcon_password.\\n");
}
else
{
remaining = "";
for (i = 2; i < Cmd.Argc(); i++)
{
remaining += Cmd.Argv(i);
remaining += " ";
}
Cmd.ExecuteString(remaining);
}
Com.EndRedirect();
}
public static void SV_Frame(Int64 msec)
{
Globals.time_before_game = Globals.time_after_game = 0;
if (!SV_INIT.svs.initialized)
{
return;
}
SV_INIT.svs.realtime += ( Int32 )msec;
Lib.Rand();
SV_CheckTimeouts();
SV_ReadPackets();
if (0 == SV_MAIN.sv_timedemo.value && SV_INIT.svs.realtime < SV_INIT.sv.time)
{
if (SV_INIT.sv.time - SV_INIT.svs.realtime > 100)
{
if (SV_MAIN.sv_showclamp.value != 0)
{
Com.Printf("sv lowclamp\\n");
}
SV_INIT.svs.realtime = SV_INIT.sv.time - 100;
}
NET.Sleep(SV_INIT.sv.time - SV_INIT.svs.realtime);
return;
}
SV_CalcPings();
SV_GiveMsec();
SV_RunGameFrame();
SV_SEND.SV_SendClientMessages();
SV_ENTS.SV_RecordDemoMessage();
Master_Heartbeat();
SV_PrepWorldFrame();
}
/**
* Master_Shutdown, Informs all masters that this server is going down.
*/
public static void Master_Shutdown()
{
int i;
// pgm post3.19 change, cvar pointer not validated before dereferencing
if (null == Globals.dedicated || 0 == Globals.dedicated.value)
{
return; // only dedicated servers send heartbeats
}
// pgm post3.19 change, cvar pointer not validated before dereferencing
if (null == SV_MAIN.public_server || 0 == SV_MAIN.public_server.value)
{
return; // a private dedicated game
}
// send to group master
for (i = 0; i < Defines.MAX_MASTERS; i++)
{
if (SV_MAIN.master_adr[i].port != 0)
{
if (i > 0)
{
Com.Printf("Sending heartbeat to " + NET.AdrToString(SV_MAIN.master_adr[i]) + "\n");
}
Netchan.OutOfBandPrint(Defines.NS_SERVER, SV_MAIN.master_adr[i], "shutdown");
}
}
}
public void send_serverinfo(string ip, int port)
{
UdpClient udpClient = new UdpClient();
IPEndPoint iPEndPoint = new IPEndPoint(IPAddress.Parse(ip), port);
UDPClient.UdpState udpState = new UDPClient.UdpState();
udpState.e = iPEndPoint;
udpState.u = udpClient;
try
{
NET.BEGIN_WRITE();
NET.WRITE_BYTE(244);
NET.WRITE_BYTE(0);
NET.WRITE_BYTE(0);
NET.WRITE_BYTE(0);
NET.WRITE_FLOAT(Time.time);
NET.END_WRITE();
udpClient.Send(NET.WRITE_DATA(), NET.WRITE_LEN(), iPEndPoint);
}
catch
{
UnityEngine.Debug.LogWarning("[udp] send error");
}
udpClient.BeginReceive(new AsyncCallback(UDPClient.ReceiveCallback), udpState);
base.StartCoroutine(this.forceclose(udpClient));
}
public static void Master_Heartbeat( )
{
String string_renamed;
Int32 i;
if (Globals.dedicated == null || 0 == Globals.dedicated.value)
{
return;
}
if (null == SV_MAIN.public_server || 0 == SV_MAIN.public_server.value)
{
return;
}
if (SV_INIT.svs.last_heartbeat > SV_INIT.svs.realtime)
{
SV_INIT.svs.last_heartbeat = SV_INIT.svs.realtime;
}
if (SV_INIT.svs.realtime - SV_INIT.svs.last_heartbeat < SV_MAIN.HEARTBEAT_SECONDS * 1000)
{
return;
}
SV_INIT.svs.last_heartbeat = SV_INIT.svs.realtime;
string_renamed = SV_StatusString();
for (i = 0; i < Defines.MAX_MASTERS; i++)
{
if (SV_MAIN.master_adr[i].port != 0)
{
Com.Printf("Sending heartbeat to " + NET.AdrToString(SV_MAIN.master_adr[i]) + "\\n");
Netchan.OutOfBandPrint(Defines.NS_SERVER, SV_MAIN.master_adr[i], "heartbeat\\n" + string_renamed);
}
}
}
public static void Netchan_OutOfBand(int net_socket, netadr_t adr, int length, byte[] data)
{
SZ.Init(send, send_buf, Defines.MAX_MSGLEN);
MSG.WriteInt(send, -1);
SZ.Write(send, data, length);
NET.SendPacket(net_socket, send.cursize, send.data, adr);
}
public static bool Process(netchan_t chan, sizebuf_t msg)
{
MSG.BeginReading(msg);
int sequence = MSG.ReadLong(msg);
int sequence_ack = MSG.ReadLong(msg);
if (chan.sock == Defines.NS_SERVER)
{
MSG.ReadShort(msg);
}
int reliable_message = sequence >> 31;
int reliable_ack = sequence_ack >> 31;
sequence &= ~(1 << 31);
sequence_ack &= ~(1 << 31);
if (showpackets.value != 0)
{
if (reliable_message != 0)
{
Com.Printf("recv " + msg.cursize + " : s=" + sequence + " reliable=" + (chan.incoming_reliable_sequence ^ 1) + " ack=" + sequence_ack + " rack=" + reliable_ack + "\\n");
}
else
{
Com.Printf("recv " + msg.cursize + " : s=" + sequence + " ack=" + sequence_ack + " rack=" + reliable_ack + "\\n");
}
}
if (sequence <= chan.incoming_sequence)
{
if (showdrop.value != 0)
{
Com.Printf(NET.AdrToString(chan.remote_address) + ":Out of order packet " + sequence + " at " + chan.incoming_sequence + "\\n");
}
return(false);
}
chan.dropped = sequence - (chan.incoming_sequence + 1);
if (chan.dropped > 0)
{
if (showdrop.value != 0)
{
Com.Printf(NET.AdrToString(chan.remote_address) + ":Dropped " + chan.dropped + " packets at " + sequence + "\\n");
}
}
if (reliable_ack == chan.reliable_sequence)
{
chan.reliable_length = 0;
}
chan.incoming_sequence = sequence;
chan.incoming_acknowledged = sequence_ack;
chan.incoming_reliable_acknowledged = reliable_ack;
if (reliable_message != 0)
{
chan.incoming_reliable_sequence ^= 1;
}
chan.last_received = (int)Globals.curtime;
return(true);
}
private static void WRITE_SHORT(short svalue)
{
byte[] array = NET.EncodeShort(svalue);
NET.sendbuffer[NET.writepos] = array[0];
NET.sendbuffer[NET.writepos + 1] = array[1];
NET.writepos += 2;
}
/// <summary>
/// 修改
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public bool Update(T entity)
{
NET net = new NET();
net.Entry <T>(entity).State = EntityState.Modified;
return(net.SaveChanges() > 0);
}
public static void SVC_GetChallenge( )
{
Int32 i;
Int32 oldest;
Int32 oldestTime;
oldest = 0;
oldestTime = 0x7fffffff;
for (i = 0; i < Defines.MAX_CHALLENGES; i++)
{
if (NET.CompareBaseAdr(Globals.net_from, SV_INIT.svs.challenges[i].adr))
{
break;
}
if (SV_INIT.svs.challenges[i].time < oldestTime)
{
oldestTime = SV_INIT.svs.challenges[i].time;
oldest = i;
}
}
if (i == Defines.MAX_CHALLENGES)
{
SV_INIT.svs.challenges[oldest].challenge = Lib.Rand() & 0x7fff;
SV_INIT.svs.challenges[oldest].adr = Globals.net_from;
SV_INIT.svs.challenges[oldest].time = ( Int32 )Globals.curtime;
i = oldest;
}
Netchan.OutOfBandPrint(Defines.NS_SERVER, Globals.net_from, "challenge " + SV_INIT.svs.challenges[i].challenge);
}
public static void Transmit(netchan_t chan, int length, byte[] data)
{
int send_reliable;
int w1, w2;
if (chan.message.overflowed)
{
chan.fatal_error = true;
Com.Printf(NET.AdrToString(chan.remote_address) + ":Outgoing message overflow\\n");
return;
}
send_reliable = Netchan_NeedReliable(chan) ? 1 : 0;
if (chan.reliable_length == 0 && chan.message.cursize != 0)
{
System.Array.Copy(chan.message_buf, 0, chan.reliable_buf, 0, chan.message.cursize);
chan.reliable_length = chan.message.cursize;
chan.message.cursize = 0;
chan.reliable_sequence ^= 1;
}
SZ.Init(send, send_buf, send_buf.Length);
w1 = (chan.outgoing_sequence & ~(1 << 31)) | (send_reliable << 31);
w2 = (chan.incoming_sequence & ~(1 << 31)) | (chan.incoming_reliable_sequence << 31);
chan.outgoing_sequence++;
chan.last_sent = (int)Globals.curtime;
MSG.WriteInt(send, w1);
MSG.WriteInt(send, w2);
if (chan.sock == Defines.NS_CLIENT)
{
MSG.WriteShort(send, (int)qport.value);
}
if (send_reliable != 0)
{
SZ.Write(send, chan.reliable_buf, chan.reliable_length);
chan.last_reliable_sequence = chan.outgoing_sequence;
}
if (send.maxsize - send.cursize >= length)
{
SZ.Write(send, data, length);
}
else
{
Com.Printf("Netchan_Transmit: dumped unreliable\\n");
}
NET.SendPacket(chan.sock, send.cursize, send.data, chan.remote_address);
if (showpackets.value != 0)
{
if (send_reliable != 0)
{
Com.Printf("send " + send.cursize + " : s=" + (chan.outgoing_sequence - 1) + " reliable=" + chan.reliable_sequence + " ack=" + chan.incoming_sequence + " rack=" + chan.incoming_reliable_sequence + "\\n");
}
else
{
Com.Printf("send " + send.cursize + " : s=" + (chan.outgoing_sequence - 1) + " ack=" + chan.incoming_sequence + " rack=" + chan.incoming_reliable_sequence + "\\n");
}
}
}
public static void SV_Status_f( )
{
Int32 i, j, l;
client_t cl;
String s;
Int32 ping;
if (SV_INIT.svs.clients == null)
{
Com.Printf("No server running.\\n");
return;
}
Com.Printf("map : " + SV_INIT.sv.name + "\\n");
Com.Printf("num score ping name lastmsg address qport \\n");
Com.Printf("--- ----- ---- --------------- ------- --------------------- ------\\n");
for (i = 0; i < SV_MAIN.maxclients.value; i++)
{
cl = SV_INIT.svs.clients[i];
if (0 == cl.state)
{
continue;
}
Com.Printf("%3i ", i);
Com.Printf("%5i ", cl.edict.client.ps.stats[Defines.STAT_FRAGS]);
if (cl.state == Defines.cs_connected)
{
Com.Printf("CNCT ");
}
else if (cl.state == Defines.cs_zombie)
{
Com.Printf("ZMBI ");
}
else
{
ping = cl.ping < 9999 ? cl.ping : 9999;
Com.Printf("%4i ", ping);
}
Com.Printf("%s", cl.name);
l = 16 - cl.name.Length;
for (j = 0; j < l; j++)
{
Com.Printf(" ");
}
Com.Printf("%7i ", SV_INIT.svs.realtime - cl.lastmessage);
s = NET.AdrToString(cl.netchan.remote_address);
Com.Printf(s);
l = 22 - s.Length;
for (j = 0; j < l; j++)
{
Com.Printf(" ");
}
Com.Printf("%5i", cl.netchan.qport);
Com.Printf("\\n");
}
Com.Printf("\\n");
}
/// <summary>
/// 删除
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public bool Delete(object id)
{
NET net = new NET();
T entity = net.Set <T>().Find(id);
net.Set <T>().Remove(entity);
return(net.SaveChanges() > 0);
}
public static void END_WRITE()
{
short svalue = (short)NET.writepos;
NET.writepos = 2;
NET.WRITE_SHORT(svalue);
NET.writepos = (int)svalue;
}
private static void WRITE_LONG(int ivalue)
{
byte[] array = NET.EncodeInteger(ivalue);
NET.sendbuffer[NET.writepos] = array[0];
NET.sendbuffer[NET.writepos + 1] = array[1];
NET.sendbuffer[NET.writepos + 2] = array[2];
NET.sendbuffer[NET.writepos + 3] = array[3];
NET.writepos += 4;
}
public static void WRITE_FLOAT(float fvalue)
{
byte[] array = NET.EncodeFloat(fvalue);
NET.sendbuffer[NET.writepos] = array[0];
NET.sendbuffer[NET.writepos + 1] = array[1];
NET.sendbuffer[NET.writepos + 2] = array[2];
NET.sendbuffer[NET.writepos + 3] = array[3];
NET.writepos += 4;
}
public static void SV_KillServer_f( )
{
if (!SV_INIT.svs.initialized)
{
return;
}
SV_MAIN.SV_Shutdown("Server was killed.\\n", false);
NET.Config(false);
}
public static void SV_ReadPackets( )
{
Int32 i;
client_t cl;
var qport = 0;
while (NET.GetPacket(Defines.NS_SERVER, Globals.net_from, Globals.net_message))
{
if ((Globals.net_message.data[0] == -1) && (Globals.net_message.data[1] == -1) && (Globals.net_message.data[2] == -1) && (Globals.net_message.data[3] == -1))
{
SV_ConnectionlessPacket();
continue;
}
MSG.BeginReading(Globals.net_message);
MSG.ReadLong(Globals.net_message);
MSG.ReadLong(Globals.net_message);
qport = MSG.ReadShort(Globals.net_message) & 0xffff;
for (i = 0; i < SV_MAIN.maxclients.value; i++)
{
cl = SV_INIT.svs.clients[i];
if (cl.state == Defines.cs_free)
{
continue;
}
if (!NET.CompareBaseAdr(Globals.net_from, cl.netchan.remote_address))
{
continue;
}
if (cl.netchan.qport != qport)
{
continue;
}
if (cl.netchan.remote_address.port != Globals.net_from.port)
{
Com.Printf("SV_ReadPackets: fixing up a translated port\\n");
cl.netchan.remote_address.port = Globals.net_from.port;
}
if (Netchan.Process(cl.netchan, Globals.net_message))
{
if (cl.state != Defines.cs_zombie)
{
cl.lastmessage = SV_INIT.svs.realtime;
SV_USER.SV_ExecuteClientMessage(cl);
}
}
break;
}
if (i != SV_MAIN.maxclients.value)
{
continue;
}
}
}
public static float READ_FLOAT()
{
if (NET.readpos + 4 > NET.readlen)
{
NET.readerror = true;
return(0f);
}
float result = NET.DecodeSingle(NET.readbuffer, NET.readpos);
NET.readpos += 4;
return(result);
}
public static int READ_LONG()
{
if (NET.readpos + 4 > NET.readlen)
{
NET.readerror = true;
return(0);
}
int result = NET.DecodeInteger(NET.readbuffer, NET.readpos);
NET.readpos += 4;
return(result);
}
/**
* A connectionless packet has four leading 0xff characters to distinguish
* it from a game channel. Clients that are in the game can still send
* connectionless packets. It is used also by rcon commands.
*/
public static void SV_ConnectionlessPacket()
{
string s;
string c;
MSG.BeginReading(Globals.net_message);
MSG.ReadLong(Globals.net_message); // skip the -1 marker
s = MSG.ReadStringLine(Globals.net_message);
Cmd.TokenizeString(s.ToCharArray(), false);
c = Cmd.Argv(0);
//for debugging purposes
//Com.Printf("Packet " + NET.AdrToString(Netchan.net_from) + " : " + c + "\n");
//Com.Printf(Lib.hexDump(net_message.data, 64, false) + "\n");
if (0 == Lib.strcmp(c, "ping"))
{
SV_MAIN.SVC_Ping();
}
else if (0 == Lib.strcmp(c, "ack"))
{
SV_MAIN.SVC_Ack();
}
else if (0 == Lib.strcmp(c, "status"))
{
SV_MAIN.SVC_Status();
}
else if (0 == Lib.strcmp(c, "info"))
{
SV_MAIN.SVC_Info();
}
else if (0 == Lib.strcmp(c, "getchallenge"))
{
SV_MAIN.SVC_GetChallenge();
}
else if (0 == Lib.strcmp(c, "connect"))
{
SV_MAIN.SVC_DirectConnect();
}
else if (0 == Lib.strcmp(c, "rcon"))
{
SV_MAIN.SVC_RemoteCommand();
}
else
{
Com.Printf("bad connectionless packet from " + NET.AdrToString(Globals.net_from) + "\n");
Com.Printf("[" + s + "]\n");
Com.Printf("" + Lib.hexDump(Globals.net_message.data, 128, false));
}
}
public static int READ_SHORT()
{
if (NET.readpos + 2 > NET.readlen)
{
NET.readerror = true;
return(0);
}
int result = NET.DecodeShort(NET.readbuffer, NET.readpos);
NET.readpos += 2;
return(result);
}
public void GetNeuroData(ref BaseSign bs)
{
double[] X = bs.GetAllIn();
double[] Y;
if (X != null)
{
if (NET != null)
{
NET.NetOUT(X, out Y);
bs.SetOut(Y);
}
}
}
/*
* ===============================================================================
*
* OPERATOR CONSOLE ONLY COMMANDS
*
* These commands can only be entered from stdin or by a remote operator datagram
* ===============================================================================
*/
/*
* ====================
* SV_SetMaster_f
*
* Specify a list of master servers
* ====================
*/
public static void SV_SetMaster_f()
{
int i, slot;
// only dedicated servers send heartbeats
if (Globals.dedicated.value == 0)
{
Com.Printf("Only dedicated servers use masters.\n");
return;
}
// make sure the server is listed public
Cvar.Set("public", "1");
for (i = 1; i < Defines.MAX_MASTERS; i++)
{
SV_MAIN.master_adr[i] = new();
}
slot = 1; // slot 0 will always contain the id master
for (i = 1; i < Cmd.Argc(); i++)
{
if (slot == Defines.MAX_MASTERS)
{
break;
}
if (!NET.StringToAdr(Cmd.Argv(i), SV_MAIN.master_adr[i]))
{
Com.Printf("Bad address: " + Cmd.Argv(i) + "\n");
continue;
}
if (SV_MAIN.master_adr[slot].port == 0)
{
SV_MAIN.master_adr[slot].port = Defines.PORT_MASTER;
}
Com.Printf("Master server at " + NET.AdrToString(SV_MAIN.master_adr[slot]) + "\n");
Com.Printf("Sending a ping.\n");
Netchan.OutOfBandPrint(Defines.NS_SERVER, SV_MAIN.master_adr[slot], "ping");
slot++;
}
SV_INIT.svs.last_heartbeat = -9999999;
}
public static void SV_ConnectionlessPacket( )
{
String s;
String c;
MSG.BeginReading(Globals.net_message);
MSG.ReadLong(Globals.net_message);
s = MSG.ReadStringLine(Globals.net_message);
Cmd.TokenizeString(s.ToCharArray(), false);
c = Cmd.Argv(0);
if (0 == Lib.Strcmp(c, "ping"))
{
SVC_Ping();
}
else if (0 == Lib.Strcmp(c, "ack"))
{
SVC_Ack();
}
else if (0 == Lib.Strcmp(c, "status"))
{
SVC_Status();
}
else if (0 == Lib.Strcmp(c, "info"))
{
SVC_Info();
}
else if (0 == Lib.Strcmp(c, "getchallenge"))
{
SVC_GetChallenge();
}
else if (0 == Lib.Strcmp(c, "connect"))
{
SVC_DirectConnect();
}
else if (0 == Lib.Strcmp(c, "rcon"))
{
SVC_RemoteCommand();
}
else
{
Com.Printf("bad connectionless packet from " + NET.AdrToString(Globals.net_from) + "\\n");
Com.Printf("[" + s + "]\\n");
Com.Printf("" + Lib.HexDump(Globals.net_message.data, 128, false));
}
}
/**
* A client issued an rcon command. Shift down the remaining args Redirect
* all printfs fromt hte server to the client.
*/
public static void SVC_RemoteCommand()
{
int i;
string remaining;
i = SV_MAIN.Rcon_Validate();
var msg = Lib.CtoJava(Globals.net_message.data, 4, 1024);
if (i == 0)
{
Com.Printf("Bad rcon from " + NET.AdrToString(Globals.net_from) + ":\n" + msg + "\n");
}
else
{
Com.Printf("Rcon from " + NET.AdrToString(Globals.net_from) + ":\n" + msg + "\n");
}
Com.BeginRedirect(
Defines.RD_PACKET,
SV_SEND.sv_outputbuf,
Defines.SV_OUTPUTBUF_LENGTH,
(target, buffer) => { SV_SEND.SV_FlushRedirect(target, Lib.stringToBytes(buffer.ToString())); }
);
if (0 == SV_MAIN.Rcon_Validate())
{
Com.Printf("Bad rcon_password.\n");
}
else
{
remaining = "";
for (i = 2; i < Cmd.Argc(); i++)
{
remaining += Cmd.Argv(i);
remaining += " ";
}
Cmd.ExecuteString(remaining);
}
Com.EndRedirect();
}
public void Send(ExtendedPlayerAgent player)
{
if (NET.IsMaster)
{
if (player == null || player.WrappedObj == null)
{
Debug.LogError("Tried to send progression data to a null player.");
return;
}
pProgressionData data = Replicator.Owner.ProgressionData.ToPacket();
data.to.Set(player.WrappedObj);
byte[] bytes = NET.GetBytesFromPacket(data, Replicator.Key, ID);
NET.Send(bytes, SNetwork.SNet_ChannelType.GameReceiveCritical, player.Owner);
}
else
{
Debug.LogError("Attempting to send progression data when not the master.");
}
}
public static void Master_Heartbeat()
{
string @string;
int i;
// pgm post3.19 change, cvar pointer not validated before dereferencing
if (Globals.dedicated == null || 0 == Globals.dedicated.value)
{
return; // only dedicated servers send heartbeats
}
// pgm post3.19 change, cvar pointer not validated before dereferencing
if (null == SV_MAIN.public_server || 0 == SV_MAIN.public_server.value)
{
return; // a private dedicated game
}
// check for time wraparound
if (SV_INIT.svs.last_heartbeat > SV_INIT.svs.realtime)
{
SV_INIT.svs.last_heartbeat = SV_INIT.svs.realtime;
}
if (SV_INIT.svs.realtime - SV_INIT.svs.last_heartbeat < SV_MAIN.HEARTBEAT_SECONDS * 1000)
{
return; // not time to send yet
}
SV_INIT.svs.last_heartbeat = SV_INIT.svs.realtime;
// send the same string that we would give for a status OOB command
@string = SV_MAIN.SV_StatusString();
// send to group master
for (i = 0; i < Defines.MAX_MASTERS; i++)
{
if (SV_MAIN.master_adr[i].port != 0)
{
Com.Printf("Sending heartbeat to " + NET.AdrToString(SV_MAIN.master_adr[i]) + "\n");
Netchan.OutOfBandPrint(Defines.NS_SERVER, SV_MAIN.master_adr[i], "heartbeat\n" + @string);
}
}
}
public static void Master_Shutdown( )
{
Int32 i;
if (null == Globals.dedicated || 0 == Globals.dedicated.value)
{
return;
}
if (null == SV_MAIN.public_server || 0 == SV_MAIN.public_server.value)
{
return;
}
for (i = 0; i < Defines.MAX_MASTERS; i++)
{
if (SV_MAIN.master_adr[i].port != 0)
{
if (i > 0)
{
Com.Printf("Sending heartbeat to " + NET.AdrToString(SV_MAIN.master_adr[i]) + "\\n");
}
Netchan.OutOfBandPrint(Defines.NS_SERVER, SV_MAIN.master_adr[i], "shutdown");
}
}
}
private void show(NET.Message mes)
{
SetText(mes);
}
private void SetText(NET.Message mes)
{
if (this.listView1.InvokeRequired)
{
MyInvoke _myInvoke = new MyInvoke(SetText);
this.Invoke(_myInvoke, new object[] { mes });
}
else
{
NET.Message m = mes as NET.Message;
ListViewItem[] lvi = new ListViewItem[m.Result.Count];
NET.FileInfo fi;
for (int i = 0; i < m.Result.Count; i++)
{
fi = m.Result[i];
lvi[i] = new ListViewItem(new string[] { fi.fileName, fi.IP, fi.Path, fi.introduction });
}
this.listView1.Items.AddRange(lvi);
}
}
void managementDataServer_OnManagementAllowed(object sender, NET.Remoting.Channels.ManagementAllowedEventArgs e)
{
if (Properties.Settings.Default.EnableRemoteManagement == false)
{
if (currentIP.Equals(e.IpAddress) || e.IpAddress.Equals("127.0.0.1") || e.IpAddress.ToLower().Equals("localhost"))
{
e.ManagementAllowed = true;
}
else
{
e.ManagementAllowed = false;
}
}
else
{
e.ManagementAllowed = true;
}
}
void tcpClientManagementDataServer_OnManagementAllowed(object sender, NET.Remoting.Channels.ManagementAllowedEventArgs e)
{
try
{
int ext = Convert.ToInt32(e.Extension);
bool allow = false;
WOSI.CallButler.Data.CallButlerDataset.ExtensionsRow row = dataProvider.GetExtensionNumber(Properties.Settings.Default.CustomerID, ext);
if (row != null)
{
allow = row.EnableManagement;
}
e.ManagementAllowed = allow;
}
catch
{
e.ManagementAllowed = false;
}
}
void tcpClientManagementDataServer_OnAuthentication(object sender, NET.Remoting.Channels.AuthenticationEventArgs e)
{
e.IsAuthenticated = managementInterfaceServer.Authenticate(e.CustomerID, e.ExtensionNumber, e.Password);
}
