znc-modules/lowercasechan.cpp at master · RealKindOne/znc-modules · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
// lowercasechan.cpp

// This module lowercases only the channel names to your IRC client.

// Directions:
//    1. Load module
//    2. /detach #Example ; /attach #example
//       OR
//       Reconnect your IRC client to ZNC

// Note: This module is set as a per network only module.
//       If you just want to work on ALL your networks just change the
//       "NETWORKMODULEDEF" into "USERMODULEDEFS" at the bottom of this file.
//       That way you only have to load it once.

#include <znc/Chan.h>
#include <znc/Client.h>
#include <znc/Message.h>
#include <znc/Modules.h>

class CLowercaseChanMod : public CModule {
  public:
    MODCONSTRUCTOR(CLowercaseChanMod) {}

    EModRet OnSendToClientMessage(CMessage& Message) override {
        // Transform channel names in various message types
        switch (Message.GetType()) {
            case CMessage::Type::Join:
                TransformJoinMessage(Message.As<CJoinMessage>());
                break;
            case CMessage::Type::Part:
                TransformPartMessage(Message.As<CPartMessage>());
                break;
            case CMessage::Type::Text:
                TransformTextMessage(Message.As<CTextMessage>());
                break;
            case CMessage::Type::Notice:
                TransformNoticeMessage(Message.As<CNoticeMessage>());
                break;
            case CMessage::Type::Topic:
                TransformTopicMessage(Message.As<CTopicMessage>());
                break;
            case CMessage::Type::Kick:
                TransformKickMessage(Message.As<CKickMessage>());
                break;
            case CMessage::Type::Mode:
                TransformModeMessage(Message.As<CModeMessage>());
                break;
            case CMessage::Type::Numeric:
                TransformNumericMessage(Message.As<CNumericMessage>());
                break;
            default:
                break;
        }

        return CONTINUE;
    }

  private:
    void TransformJoinMessage(CJoinMessage& Message) {
        CString sChannel = Message.GetTarget();
        if (IsChannel(sChannel)) {
            Message.SetTarget(sChannel.AsLower());
        }
    }

    void TransformPartMessage(CPartMessage& Message) {
        CString sChannel = Message.GetTarget();
        if (IsChannel(sChannel)) {
            Message.SetTarget(sChannel.AsLower());
        }
    }

    void TransformTextMessage(CTextMessage& Message) {
        CString sTarget = Message.GetTarget();
        if (IsChannel(sTarget)) {
            Message.SetTarget(sTarget.AsLower());
        }
    }

    void TransformNoticeMessage(CNoticeMessage& Message) {
        CString sTarget = Message.GetTarget();
        if (IsChannel(sTarget)) {
            Message.SetTarget(sTarget.AsLower());
        }
    }

    void TransformTopicMessage(CTopicMessage& Message) {
        CString sChannel = Message.GetTarget();
        if (IsChannel(sChannel)) {
            Message.SetTarget(sChannel.AsLower());
        }
    }

    void TransformKickMessage(CKickMessage& Message) {
        CString sChannel = Message.GetTarget();
        if (IsChannel(sChannel)) {
            Message.SetTarget(sChannel.AsLower());
        }
    }

    void TransformModeMessage(CModeMessage& Message) {
        CString sTarget = Message.GetTarget();
        if (IsChannel(sTarget)) {
            Message.SetTarget(sTarget.AsLower());
        }
    }

    void TransformNumericMessage(CNumericMessage& Message) {
        unsigned int uCode = Message.GetCode();

        switch (uCode) {
            case 353:  // RPL_NAMES
                TransformNamesReply(Message);
                break;
            case 332:  // RPL_TOPIC
            case 333:  // RPL_TOPICWHOTIME
            case 366:  // RPL_ENDOFNAMES
                TransformChannelParam(Message, 1);
                break;
            default:
                // Check if first parameter is a channel
                if (Message.GetParams().size() > 1) {
                    TransformChannelParam(Message, 1);
                }
                break;
        }
    }

    void TransformNamesReply(CNumericMessage& Message) {
        // RPL_NAMES: :server 353 nick = #channel :name1 name2 name3
        if (Message.GetParams().size() >= 3) {
            CString sChannel = Message.GetParam(2);
            if (IsChannel(sChannel)) {
                Message.SetParam(2, sChannel.AsLower());
            }
        }
    }

    void TransformChannelParam(CNumericMessage& Message, size_t uParamIndex) {
        if (Message.GetParams().size() > uParamIndex) {
            CString sChannel = Message.GetParam(uParamIndex);
            if (IsChannel(sChannel)) {
                Message.SetParam(uParamIndex, sChannel.AsLower());
            }
        }
    }

    bool IsChannel(const CString& sName) {
        return !sName.empty() && (sName[0] == '#' || sName[0] == '&' ||
                                  sName[0] == '!' || sName[0] == '+');
    }
};

NETWORKMODULEDEFS(CLowercaseChanMod, "Lowercase channel names for all IRC events")