← Back to branch summary

~ubuntu-branches/ubuntu/trusty/smuxi/trusty-proposed

« back to all changes in this revision

Viewing changes to lib/SmartIrc4net/src/IrcClient/IrcClient.cs

  • Committer: Package Import Robot
  • Author(s): Mirco Bauer
  • Date: 2013-05-25 22:11:31 UTC
  • mfrom: (1.2.12)
  • Revision ID: package-import@ubuntu.com-20130525221131-nd2mc0kzubuwyx20
Tags: 0.8.11-1
* [22d13d5] Imported Upstream version 0.8.11
* [6d2b95a] Refreshed patches
* [89eb66e] Added ServiceStack libraries to smuxi-engine package
* [848ab10] Enable Campfire engine
* [c6dbdc7] Always build db4o for predictable build result
* [13ec489] Exclude OS X specific libraries from dh_clideps

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/SmartIrc4net/src/IrcClient/IrcClient.cs
113
113
        public event InviteEventHandler         OnInvite;
114
114
        public event BanEventHandler            OnBan;
115
115
        public event UnbanEventHandler          OnUnban;
 
116
        public event OwnerEventHandler          OnOwner;
 
117
        public event DeownerEventHandler        OnDeowner;
 
118
        public event ChannelAdminEventHandler   OnChannelAdmin;
 
119
        public event DeChannelAdminEventHandler OnDeChannelAdmin;
116
120
        public event OpEventHandler             OnOp;
117
121
        public event DeopEventHandler           OnDeop;
118
122
        public event HalfopEventHandler         OnHalfop;
1373
1377
            chan.UnsafeVoices.Remove(nickname);
1374
1378
            if (SupportNonRfc) {
1375
1379
                NonRfcChannel nchan = (NonRfcChannel)chan;
 
1380
                nchan.UnsafeOwners.Remove(nickname);
 
1381
                nchan.UnsafeChannelAdmins.Remove(nickname);
1376
1382
                nchan.UnsafeHalfops.Remove(nickname);
1377
1383
            } 
1378
1384
        }
1471
1477
                            }
1472
1478
                        }
1473
1479
                    break;
 
1480
                    case 'q':
 
1481
                        if (SupportNonRfc) {
 
1482
                            temp = (string)parametersEnumerator.Current;
 
1483
                            parametersEnumerator.MoveNext();
 
1484
 
 
1485
                            if (add) {
 
1486
                                if (ActiveChannelSyncing && channel != null) {
 
1487
                                    // sanity check
 
1488
                                    if (GetChannelUser(ircdata.Channel, temp) != null) {
 
1489
                                        // update the owner list
 
1490
                                        try {
 
1491
                                            ((NonRfcChannel)channel).UnsafeOwners.Add(temp, GetIrcUser(temp));
 
1492
#if LOG4NET
 
1493
                                            Logger.ChannelSyncing.Debug("added owner: "+temp+" to: "+ircdata.Channel);
 
1494
#endif
 
1495
                                        } catch (ArgumentException) {
 
1496
#if LOG4NET
 
1497
                                            Logger.ChannelSyncing.Debug("duplicate owner: "+temp+" in: "+ircdata.Channel+" not added");
 
1498
#endif
 
1499
                                        }
 
1500
 
 
1501
                                        // update the user owner status
 
1502
                                        NonRfcChannelUser cuser = (NonRfcChannelUser)GetChannelUser(ircdata.Channel, temp);
 
1503
                                        cuser.IsOwner = true;
 
1504
#if LOG4NET
 
1505
                                        Logger.ChannelSyncing.Debug("set owner status: " + temp + " for: "+ircdata.Channel);
 
1506
#endif
 
1507
                                    } else {
 
1508
#if LOG4NET
 
1509
                                        Logger.ChannelSyncing.Error("_InterpretChannelMode(): GetChannelUser(" + ircdata.Channel + "," + temp + ") returned null! Ignoring...");
 
1510
#endif
 
1511
                                    }
 
1512
                                }
 
1513
 
 
1514
                                if (OnOwner != null) {
 
1515
                                    OnOwner(this, new OwnerEventArgs(ircdata, ircdata.Channel, ircdata.Nick, temp));
 
1516
                                }
 
1517
                            }
 
1518
                            if (remove) {
 
1519
                                if (ActiveChannelSyncing && channel != null) {
 
1520
                                    // sanity check
 
1521
                                    if (GetChannelUser(ircdata.Channel, temp) != null) {
 
1522
                                        // update the owner list
 
1523
                                        ((NonRfcChannel)channel).UnsafeOwners.Remove(temp);
 
1524
#if LOG4NET
 
1525
                                        Logger.ChannelSyncing.Debug("removed owner: "+temp+" from: "+ircdata.Channel);
 
1526
#endif
 
1527
                                        // update the user owner status
 
1528
                                        NonRfcChannelUser cuser = (NonRfcChannelUser)GetChannelUser(ircdata.Channel, temp);
 
1529
                                        cuser.IsOwner = false;
 
1530
#if LOG4NET
 
1531
                                        Logger.ChannelSyncing.Debug("unset owner status: " + temp + " for: "+ircdata.Channel);
 
1532
#endif
 
1533
                                    } else {
 
1534
#if LOG4NET
 
1535
                                        Logger.ChannelSyncing.Error("_InterpretChannelMode(): GetChannelUser(" + ircdata.Channel + "," + temp + ") returned null! Ignoring...");
 
1536
#endif
 
1537
                                    }
 
1538
                                }
 
1539
 
 
1540
                                if (OnDeowner != null) {
 
1541
                                    OnDeowner(this, new DeownerEventArgs(ircdata, ircdata.Channel, ircdata.Nick, temp));
 
1542
                                }
 
1543
                            }
 
1544
                        }
 
1545
                    break;
 
1546
                    case 'a':
 
1547
                        if (SupportNonRfc) {
 
1548
                            temp = (string)parametersEnumerator.Current;
 
1549
                            parametersEnumerator.MoveNext();
 
1550
 
 
1551
                            if (add) {
 
1552
                                if (ActiveChannelSyncing && channel != null) {
 
1553
                                    // sanity check
 
1554
                                    if (GetChannelUser(ircdata.Channel, temp) != null) {
 
1555
                                        // update the channel admin list
 
1556
                                        try {
 
1557
                                            ((NonRfcChannel)channel).UnsafeChannelAdmins.Add(temp, GetIrcUser(temp));
 
1558
#if LOG4NET
 
1559
                                            Logger.ChannelSyncing.Debug("added channel admin: "+temp+" to: "+ircdata.Channel);
 
1560
#endif
 
1561
                                        } catch (ArgumentException) {
 
1562
#if LOG4NET
 
1563
                                            Logger.ChannelSyncing.Debug("duplicate channel admin: "+temp+" in: "+ircdata.Channel+" not added");
 
1564
#endif
 
1565
                                        }
 
1566
 
 
1567
                                        // update the user channel admin status
 
1568
                                        NonRfcChannelUser cuser = (NonRfcChannelUser)GetChannelUser(ircdata.Channel, temp);
 
1569
                                        cuser.IsChannelAdmin = true;
 
1570
#if LOG4NET
 
1571
                                        Logger.ChannelSyncing.Debug("set channel admin status: " + temp + " for: "+ircdata.Channel);
 
1572
#endif
 
1573
                                    } else {
 
1574
#if LOG4NET
 
1575
                                        Logger.ChannelSyncing.Error("_InterpretChannelMode(): GetChannelUser(" + ircdata.Channel + "," + temp + ") returned null! Ignoring...");
 
1576
#endif
 
1577
                                    }
 
1578
                                }
 
1579
 
 
1580
                                if (OnChannelAdmin != null) {
 
1581
                                    OnChannelAdmin(this, new ChannelAdminEventArgs(ircdata, ircdata.Channel, ircdata.Nick, temp));
 
1582
                                }
 
1583
                            }
 
1584
                            if (remove) {
 
1585
                                if (ActiveChannelSyncing && channel != null) {
 
1586
                                    // sanity check
 
1587
                                    if (GetChannelUser(ircdata.Channel, temp) != null) {
 
1588
                                        // update the channel admin list
 
1589
                                        ((NonRfcChannel)channel).UnsafeChannelAdmins.Remove(temp);
 
1590
#if LOG4NET
 
1591
                                        Logger.ChannelSyncing.Debug("removed channel admin: "+temp+" from: "+ircdata.Channel);
 
1592
#endif
 
1593
                                        // update the user channel admin status
 
1594
                                        NonRfcChannelUser cuser = (NonRfcChannelUser)GetChannelUser(ircdata.Channel, temp);
 
1595
                                        cuser.IsChannelAdmin = false;
 
1596
#if LOG4NET
 
1597
                                        Logger.ChannelSyncing.Debug("unset channel admin status: " + temp + " for: "+ircdata.Channel);
 
1598
#endif
 
1599
                                    } else {
 
1600
#if LOG4NET
 
1601
                                        Logger.ChannelSyncing.Error("_InterpretChannelMode(): GetChannelUser(" + ircdata.Channel + "," + temp + ") returned null! Ignoring...");
 
1602
#endif
 
1603
                                    }
 
1604
                                }
 
1605
 
 
1606
                                if (OnDeChannelAdmin != null) {
 
1607
                                    OnDeChannelAdmin(this, new DeChannelAdminEventArgs(ircdata, ircdata.Channel, ircdata.Nick, temp));
 
1608
                                }
 
1609
                            }
 
1610
                        }
 
1611
                    break;
1474
1612
                    case 'h':
1475
1613
                        if (SupportNonRfc) {
1476
1614
                            temp = (string)parametersEnumerator.Current;
1806
1944
                    // ignore
1807
1945
                } else {
1808
1946
                    ChannelUser channeluser = CreateChannelUser(channelname, ircuser);
1809
 
                    channel.UnsafeUsers.Add(who, channeluser);
 
1947
                    channel.UnsafeUsers[who] = channeluser;
1810
1948
                }
1811
1949
            }
1812
1950
 
2094
2232
                        // remove first to avoid duplication, Foo -> foo
2095
2233
                        channel.UnsafeUsers.Remove(oldnickname);
2096
2234
                        channel.UnsafeUsers.Add(newnickname, channeluser);
 
2235
                        if (SupportNonRfc && ((NonRfcChannelUser)channeluser).IsOwner) {
 
2236
                            NonRfcChannel nchannel = (NonRfcChannel)channel;
 
2237
                            nchannel.UnsafeOwners.Remove(oldnickname);
 
2238
                            nchannel.UnsafeOwners.Add(newnickname, channeluser);
 
2239
                        }
 
2240
                        if (SupportNonRfc && ((NonRfcChannelUser)channeluser).IsChannelAdmin) {
 
2241
                            NonRfcChannel nchannel = (NonRfcChannel)channel;
 
2242
                            nchannel.UnsafeChannelAdmins.Remove(oldnickname);
 
2243
                            nchannel.UnsafeChannelAdmins.Add(newnickname, channeluser);
 
2244
                        }
2097
2245
                        if (channeluser.IsOp) {
2098
2246
                            channel.UnsafeOps.Remove(oldnickname);
2099
2247
                            channel.UnsafeOps.Add(newnickname, channeluser);
2258
2406
            if (ActiveChannelSyncing &&
2259
2407
                IsJoined(channelname)) {
2260
2408
                string nickname;
 
2409
                bool   owner;
 
2410
                bool   chanadmin;
2261
2411
                bool   op;
2262
2412
                bool   halfop;
2263
2413
                bool   voice;
2266
2416
                        continue;
2267
2417
                    }
2268
2418
 
 
2419
                    owner = false;
 
2420
                    chanadmin = false;
2269
2421
                    op = false;
2270
2422
                    halfop = false;
2271
2423
                    voice = false;
2272
2424
                    switch (user[0]) {
 
2425
                        case '~':
 
2426
                            owner = true;
 
2427
                            nickname = user.Substring(1);
 
2428
                        break;
 
2429
                        case '&':
 
2430
                            chanadmin = true;
 
2431
                            nickname = user.Substring(1);
 
2432
                        break;
2273
2433
                        case '@':
2274
2434
                            op = true;
2275
2435
                            nickname = user.Substring(1);
2278
2438
                            voice = true;
2279
2439
                            nickname = user.Substring(1);
2280
2440
                        break;
2281
 
                        // RFC VIOLATION
2282
 
                        // some IRC network do this and break our channel sync...
2283
 
                        case '&':
2284
 
                            nickname = user.Substring(1);
2285
 
                        break;
2286
2441
                        case '%':
2287
2442
                            halfop = true;
2288
2443
                            nickname = user.Substring(1);
2289
2444
                        break;
2290
 
                        case '~':
2291
 
                            nickname = user.Substring(1);
2292
 
                        break;
2293
2445
                        default:
2294
2446
                            nickname = user;
2295
2447
                        break;
2315
2467
                        Channel channel = GetChannel(channelname);
2316
2468
                        
2317
2469
                        channel.UnsafeUsers.Add(nickname, channeluser);
 
2470
                        if (SupportNonRfc && owner) {
 
2471
                            ((NonRfcChannel)channel).UnsafeOwners.Add(nickname, channeluser);
 
2472
#if LOG4NET
 
2473
                            Logger.ChannelSyncing.Debug("added owner: "+nickname+" to: "+channelname);
 
2474
#endif
 
2475
                        }
 
2476
                        if (SupportNonRfc && chanadmin) {
 
2477
                            ((NonRfcChannel)channel).UnsafeChannelAdmins.Add(nickname, channeluser);
 
2478
#if LOG4NET
 
2479
                            Logger.ChannelSyncing.Debug("added channel admin: "+nickname+" to: "+channelname);
 
2480
#endif
 
2481
                        }
2318
2482
                        if (op) {
2319
2483
                            channel.UnsafeOps.Add(nickname, channeluser);
2320
2484
#if LOG4NET
2338
2502
                    channeluser.IsOp    = op;
2339
2503
                    channeluser.IsVoice = voice;
2340
2504
                    if (SupportNonRfc) {
2341
 
                        ((NonRfcChannelUser)channeluser).IsHalfop = halfop;
 
2505
                        var nchanneluser = (NonRfcChannelUser)channeluser;
 
2506
                        nchanneluser.IsOwner = owner;
 
2507
                        nchanneluser.IsChannelAdmin = chanadmin;
 
2508
                        nchanneluser.IsHalfop = halfop;
2342
2509
                    }
2343
2510
                }
2344
2511
            }
2368
2535
 
2369
2536
            if (OnNames != null) {
2370
2537
                OnNames(this, new NamesEventArgs(ircdata, channelname,
2371
 
                                                 filteredUserlist.ToArray()));
 
2538
                                                 filteredUserlist.ToArray(), userlist));
2372
2539
            }
2373
2540
        }
2374
2541