WebSVN – clockwerk-opensim-stable – Blame – Rev 1 – /OpenSim/Region/OptionalModules/Avatar/Chat/RegionState.cs

        private static readonly OpenMetaverse.Vector3 CenterOfRegion = new OpenMetaverse.Vector3(((int)Constants.RegionSize * 0.5f), ((int)Constants.RegionSize * 0.5f), 20);

48

private const int DEBUG_CHANNEL = 2147483647;

49

50

private static int _idk_ = 0;

51

52

// Runtime variables; these values are assigned when the

53

// IrcState is created and remain constant thereafter.

54

55

internal string Region = String.Empty;

56

internal string Host = String.Empty;

57

internal string LocX = String.Empty;

58

internal string LocY = String.Empty;

59

internal string IDK = String.Empty;

60

61

// System values - used only be the IRC classes themselves

62

63

internal ChannelState cs = null; // associated IRC configuration

64

internal Scene scene = null; // associated scene

65

internal IConfig config = null; // configuration file reference

66

internal bool enabled = true;

67

68

//AgentAlert

69

internal bool showAlert = false;

70

internal string alertMessage = String.Empty;

71

internal IDialogModule dialogModule = null;

72

73

// This list is used to keep track of who is here, and by

74

// implication, who is not.

75

76

internal List<IClientAPI> clients = new List<IClientAPI>();

77

78

// Setup runtime variable values

79

80

public RegionState(Scene p_scene, IConfig p_config)

{

scene = p_scene;

config = p_config;

Region = scene.RegionInfo.RegionName;

86

Host = scene.RegionInfo.ExternalHostName;

87

LocX = Convert.ToString(scene.RegionInfo.RegionLocX);

88

LocY = Convert.ToString(scene.RegionInfo.RegionLocY);

89

IDK = Convert.ToString(_idk_++);

90

91

showAlert = config.GetBoolean("alert_show", false);

92

string alertServerInfo = String.Empty;

if (showAlert)

{

bool showAlertServerInfo = config.GetBoolean("alert_show_serverinfo", true);

97

98

if (showAlertServerInfo)

99

alertServerInfo = String.Format("\nServer: {0}\nPort: {1}\nChannel: {2}\n\n",

100

config.GetString("server", ""), config.GetString("port", ""), config.GetString("channel", ""));

101

102

string alertPreMessage = config.GetString("alert_msg_pre", "This region is linked to Irc.");

103

                string alertPostMessage = config.GetString("alert_msg_post", "Everything you say in public chat can be listened.");

104

105

alertMessage = String.Format("{0}\n{1}{2}", alertPreMessage, alertServerInfo, alertPostMessage);

106

107

dialogModule = scene.RequestModuleInterface<IDialogModule>();

108

}

109

110

// OpenChannel conditionally establishes a connection to the

111

// IRC server. The request will either succeed, or it will

112

// throw an exception.

113

114

ChannelState.OpenChannel(this, config);

115

116

// Connect channel to world events

117

118

scene.EventManager.OnChatFromWorld += OnSimChat;

119

scene.EventManager.OnChatFromClient += OnSimChat;

120

scene.EventManager.OnMakeRootAgent += OnMakeRootAgent;

121

scene.EventManager.OnMakeChildAgent += OnMakeChildAgent;

122

123

m_log.InfoFormat("[IRC-Region {0}] Initialization complete", Region);

}

// Auto cleanup when abandoned

~RegionState()

{

if (cs != null)

cs.RemoveRegion(this);

133

}

134

135

// Called by PostInitialize after all regions have been created

public void Open()

{

cs.Open(this);

enabled = true;

}

// Called by IRCBridgeModule.Close immediately prior to unload

144

// of the module for this region. This happens when the region

145

// is being removed or the server is terminating. The IRC

146

// BridgeModule will remove the region from the region list

147

// when control returns.

148

149

public void Close()

{

enabled = false;

cs.Close(this);

}

// The agent has disconnected, cleanup associated resources

156

157

private void OnClientLoggedOut(IClientAPI client)

{

try

{

if (clients.Contains(client))

162

{

163

if (enabled && (cs.irc.Enabled) && (cs.irc.Connected) && (cs.ClientReporting))

164

{

165

m_log.InfoFormat("[IRC-Region {0}]: {1} has left", Region, client.Name);

166

//Check if this person is excluded from IRC

167

if (!cs.ExcludeList.Contains(client.Name.ToLower()))

168

{

169

                            cs.irc.PrivMsg(cs.NoticeMessageFormat, cs.irc.Nick, Region, String.Format("{0} has left", client.Name));

170

}

171

}

172

client.OnLogout -= OnClientLoggedOut;

173

client.OnConnectionClosed -= OnClientLoggedOut;

174

clients.Remove(client);

175

}

176

}

177

catch (Exception ex)

178

{

179

m_log.ErrorFormat("[IRC-Region {0}]: ClientLoggedOut exception: {1}", Region, ex.Message);

m_log.Debug(ex);

}

}

// This event indicates that the agent has left the building. We should treat that the same

185

// as if the agent has logged out (we don't want cross-region noise - or do we?)

186

187

private void OnMakeChildAgent(ScenePresence presence)

188

{

189

190

IClientAPI client = presence.ControllingClient;

try

{

if (clients.Contains(client))

195

{

196

if (enabled && (cs.irc.Enabled) && (cs.irc.Connected) && (cs.ClientReporting))

197

{

198

string clientName = String.Format("{0} {1}", presence.Firstname, presence.Lastname);

199

m_log.DebugFormat("[IRC-Region {0}] {1} has left", Region, clientName);

200

                        cs.irc.PrivMsg(cs.NoticeMessageFormat, cs.irc.Nick, Region, String.Format("{0} has left", clientName));

201

}

202

client.OnLogout -= OnClientLoggedOut;

203

client.OnConnectionClosed -= OnClientLoggedOut;

204

clients.Remove(client);

205

}

206

}

207

catch (Exception ex)

208

{

209

m_log.ErrorFormat("[IRC-Region {0}]: MakeChildAgent exception: {1}", Region, ex.Message);

m_log.Debug(ex);

}

}

// An agent has entered the region (from another region). Add the client to the locally

216

// known clients list

217

218

private void OnMakeRootAgent(ScenePresence presence)

219

{

220

IClientAPI client = presence.ControllingClient;

try

{

if (!clients.Contains(client))

225

{

226

client.OnLogout += OnClientLoggedOut;

227

client.OnConnectionClosed += OnClientLoggedOut;

228

clients.Add(client);

229

if (enabled && (cs.irc.Enabled) && (cs.irc.Connected) && (cs.ClientReporting))

230

{

231

string clientName = String.Format("{0} {1}", presence.Firstname, presence.Lastname);

232

m_log.DebugFormat("[IRC-Region {0}] {1} has arrived", Region, clientName);

233

//Check if this person is excluded from IRC

234

if (!cs.ExcludeList.Contains(clientName.ToLower()))

235

{

236

                            cs.irc.PrivMsg(cs.NoticeMessageFormat, cs.irc.Nick, Region, String.Format("{0} has arrived", clientName));

}

}

}

if (dialogModule != null && showAlert)

242

dialogModule.SendAlertToUser(client, alertMessage, true);

243

}

244

catch (Exception ex)

245

{

246

m_log.ErrorFormat("[IRC-Region {0}]: MakeRootAgent exception: {1}", Region, ex.Message);

m_log.Debug(ex);

}

}

// This handler detects chat events int he virtual world.

252

public void OnSimChat(Object sender, OSChatMessage msg)

253

{

254

255

// early return if this comes from the IRC forwarder

256

257

if (cs.irc.Equals(sender)) return;

258

259

// early return if nothing to forward

260

261

if (msg.Message.Length == 0) return;

262

263

// check for commands coming from avatars or in-world

264

// object (if commands are enabled)

265

266

if (cs.CommandsEnabled && msg.Channel == cs.CommandChannel)

267

{

268

269

m_log.DebugFormat("[IRC-Region {0}] command on channel {1}: {2}", Region, msg.Channel, msg.Message);

270

271

string[] messages = msg.Message.Split(' ');

272

string command = messages[0].ToLower();

try

{

switch (command)

{

// These commands potentially require a change in the

280

// underlying ChannelState.

case "server":

cs.Close(this);

cs = cs.UpdateServer(this, messages[1]);

cs.Open(this);

break;

case "port":

cs.Close(this);

cs = cs.UpdatePort(this, messages[1]);

cs.Open(this);

break;

case "channel":

cs.Close(this);

cs = cs.UpdateChannel(this, messages[1]);

cs.Open(this);

break;

case "nick":

cs.Close(this);

cs = cs.UpdateNickname(this, messages[1]);

cs.Open(this);

break;

// These may also (but are less likely) to require a

304

// change in ChannelState.

305

306

case "client-reporting":

307

cs = cs.UpdateClientReporting(this, messages[1]);

308

break;

309

case "in-channel":

310

cs = cs.UpdateRelayIn(this, messages[1]);

311

break;

312

case "out-channel":

313

cs = cs.UpdateRelayOut(this, messages[1]);

314

break;

315

316

// These are all taken to be temporary changes in state

317

// so the underlying connector remains intact. But note

318

// that with regions sharing a connector, there could

319

// be interference.

case "close":

enabled = false;

cs.Close(this);

break;

case "connect":

enabled = true;

cs.Open(this);

break;

case "reconnect":

enabled = true;

cs.Close(this);

cs.Open(this);

break;

// This one is harmless as far as we can judge from here.

338

// If it is not, then the complaints will eventually make

// that evident.

default:

m_log.DebugFormat("[IRC-Region {0}] Forwarding unrecognized command to IRC : {1}",

343

Region, msg.Message);

344

cs.irc.Send(msg.Message);

break;

}

}

catch (Exception ex)

349

{

350

m_log.WarnFormat("[IRC-Region {0}] error processing in-world command channel input: {1}",

351

Region, ex.Message);

m_log.Debug(ex);

}

return;

}

// The command channel remains enabled, even if we have otherwise disabled the IRC

// interface.

if (!enabled)

return;

// drop messages unless they are on a valid in-world

366

// channel as configured in the ChannelState

367

368

if (!cs.ValidInWorldChannels.Contains(msg.Channel))

369

{

370

m_log.DebugFormat("[IRC-Region {0}] dropping message {1} on channel {2}", Region, msg, msg.Channel);

return;

}

ScenePresence avatar = null;

375

string fromName = msg.From;

376

377

if (msg.Sender != null)

378

{

379

avatar = scene.GetScenePresence(msg.Sender.AgentId);

380

if (avatar != null) fromName = avatar.Name;

381

}

382

383

if (!cs.irc.Connected)

384

{

385

                m_log.WarnFormat("[IRC-Region {0}] IRCConnector not connected: dropping message from {1}", Region, fromName);

return;

}

m_log.DebugFormat("[IRC-Region {0}] heard on channel {1} : {2}", Region, msg.Channel, msg.Message);

390

391

if (null != avatar && cs.RelayChat && (msg.Channel == 0 || msg.Channel == DEBUG_CHANNEL))

392

{

393

string txt = msg.Message;

394

if (txt.StartsWith("/me "))

395

txt = String.Format("{0} {1}", fromName, msg.Message.Substring(4));

396

397

cs.irc.PrivMsg(cs.PrivateMessageFormat, fromName, Region, txt);

return;

}

if (null == avatar && cs.RelayPrivateChannels && null != cs.AccessPassword &&

402

msg.Channel == cs.RelayChannelOut)

403

{

404

Match m = cs.AccessPasswordRegex.Match(msg.Message);

405

if (null != m)

406

{

407

m_log.DebugFormat("[IRC] relaying message from {0}: {1}", m.Groups["avatar"].ToString(),

408

m.Groups["message"].ToString());

409

cs.irc.PrivMsg(cs.PrivateMessageFormat, m.Groups["avatar"].ToString(),

410

scene.RegionInfo.RegionName, m.Groups["message"].ToString());

}

}

}

// This method gives the region an opportunity to interfere with

416

// message delivery. For now we just enforce the enable/disable

417

// flag.

418

419

internal void OSChat(Object irc, OSChatMessage msg)

{

if (enabled)

{

// m_log.DebugFormat("[IRC-OSCHAT] Region {0} being sent message", region.Region);

424

msg.Scene = scene;

425

scene.EventManager.TriggerOnChatBroadcast(irc, msg);

}

}

// This supports any local message traffic that might be needed in

430

// support of command processing. At present there is none.

431

432

internal void LocalChat(string msg)

{

if (enabled)

{

OSChatMessage osm = new OSChatMessage();

437

osm.From = "IRC Agent";

438

osm.Message = msg;

439

osm.Type = ChatTypeEnum.Region;

440

osm.Position = CenterOfRegion;

441

osm.Sender = null;

442

osm.SenderUUID = OpenMetaverse.UUID.Zero; // Hmph! Still?

osm.Channel = 0;

OSChat(this, osm);

}

}

}

}

clockwerk-opensim-stable – Blame information for rev 1