aboutsummaryrefslogtreecommitdiff
path: root/src/messenger/messenger_api_message_kind.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/messenger/messenger_api_message_kind.c')
-rw-r--r--src/messenger/messenger_api_message_kind.c83
1 files changed, 52 insertions, 31 deletions
diff --git a/src/messenger/messenger_api_message_kind.c b/src/messenger/messenger_api_message_kind.c
index 97eaa061b..5a13620cc 100644
--- a/src/messenger/messenger_api_message_kind.c
+++ b/src/messenger/messenger_api_message_kind.c
@@ -31,74 +31,84 @@
31struct GNUNET_MESSENGER_Message* 31struct GNUNET_MESSENGER_Message*
32create_message_join (const struct GNUNET_IDENTITY_PrivateKey *key) 32create_message_join (const struct GNUNET_IDENTITY_PrivateKey *key)
33{ 33{
34 if (!key) 34 if (! key)
35 return NULL; 35 return NULL;
36 36
37 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_JOIN); 37 struct GNUNET_MESSENGER_Message *message = create_message (
38 GNUNET_MESSENGER_KIND_JOIN);
38 39
39 if (!message) 40 if (! message)
40 return NULL; 41 return NULL;
41 42
42 GNUNET_IDENTITY_key_get_public (key, &(message->body.join.key)); 43 GNUNET_IDENTITY_key_get_public (key, &(message->body.join.key));
43 return message; 44 return message;
44} 45}
45 46
47
46struct GNUNET_MESSENGER_Message* 48struct GNUNET_MESSENGER_Message*
47create_message_leave () 49create_message_leave ()
48{ 50{
49 return create_message (GNUNET_MESSENGER_KIND_LEAVE); 51 return create_message (GNUNET_MESSENGER_KIND_LEAVE);
50} 52}
51 53
54
52struct GNUNET_MESSENGER_Message* 55struct GNUNET_MESSENGER_Message*
53create_message_name (const char *name) 56create_message_name (const char *name)
54{ 57{
55 if (!name) 58 if (! name)
56 return NULL; 59 return NULL;
57 60
58 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_NAME); 61 struct GNUNET_MESSENGER_Message *message = create_message (
62 GNUNET_MESSENGER_KIND_NAME);
59 63
60 if (!message) 64 if (! message)
61 return NULL; 65 return NULL;
62 66
63 message->body.name.name = GNUNET_strdup(name); 67 message->body.name.name = GNUNET_strdup (name);
64 return message; 68 return message;
65} 69}
66 70
71
67struct GNUNET_MESSENGER_Message* 72struct GNUNET_MESSENGER_Message*
68create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key) 73create_message_key (const struct GNUNET_IDENTITY_PrivateKey *key)
69{ 74{
70 if (!key) 75 if (! key)
71 return NULL; 76 return NULL;
72 77
73 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_KEY); 78 struct GNUNET_MESSENGER_Message *message = create_message (
79 GNUNET_MESSENGER_KIND_KEY);
74 80
75 if (!message) 81 if (! message)
76 return NULL; 82 return NULL;
77 83
78 GNUNET_IDENTITY_key_get_public (key, &(message->body.key.key)); 84 GNUNET_IDENTITY_key_get_public (key, &(message->body.key.key));
79 return message; 85 return message;
80} 86}
81 87
88
82struct GNUNET_MESSENGER_Message* 89struct GNUNET_MESSENGER_Message*
83create_message_id (const struct GNUNET_ShortHashCode *unique_id) 90create_message_id (const struct GNUNET_ShortHashCode *unique_id)
84{ 91{
85 if (!unique_id) 92 if (! unique_id)
86 return NULL; 93 return NULL;
87 94
88 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_ID); 95 struct GNUNET_MESSENGER_Message *message = create_message (
96 GNUNET_MESSENGER_KIND_ID);
89 97
90 if (!message) 98 if (! message)
91 return NULL; 99 return NULL;
92 100
93 GNUNET_memcpy(&(message->body.id.id), unique_id, sizeof(struct GNUNET_ShortHashCode)); 101 GNUNET_memcpy (&(message->body.id.id), unique_id, sizeof(struct
102 GNUNET_ShortHashCode));
94 103
95 return message; 104 return message;
96} 105}
97 106
107
98struct GNUNET_MESSENGER_Message* 108struct GNUNET_MESSENGER_Message*
99create_message_request (const struct GNUNET_HashCode *hash) 109create_message_request (const struct GNUNET_HashCode *hash)
100{ 110{
101 if (!hash) 111 if (! hash)
102 return NULL; 112 return NULL;
103 113
104 struct GNUNET_HashCode zero; 114 struct GNUNET_HashCode zero;
@@ -107,62 +117,73 @@ create_message_request (const struct GNUNET_HashCode *hash)
107 if (0 == GNUNET_CRYPTO_hash_cmp (hash, &zero)) 117 if (0 == GNUNET_CRYPTO_hash_cmp (hash, &zero))
108 return NULL; 118 return NULL;
109 119
110 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_REQUEST); 120 struct GNUNET_MESSENGER_Message *message = create_message (
121 GNUNET_MESSENGER_KIND_REQUEST);
111 122
112 if (!message) 123 if (! message)
113 return NULL; 124 return NULL;
114 125
115 GNUNET_memcpy(&(message->body.request.hash), hash, sizeof(struct GNUNET_HashCode)); 126 GNUNET_memcpy (&(message->body.request.hash), hash, sizeof(struct
127 GNUNET_HashCode));
116 128
117 return message; 129 return message;
118} 130}
119 131
132
120struct GNUNET_MESSENGER_Message* 133struct GNUNET_MESSENGER_Message*
121create_message_invite (const struct GNUNET_PeerIdentity *door, 134create_message_invite (const struct GNUNET_PeerIdentity *door,
122 const struct GNUNET_HashCode *key) 135 const struct GNUNET_HashCode *key)
123{ 136{
124 if ((!door) || (!key)) 137 if ((! door) || (! key))
125 return NULL; 138 return NULL;
126 139
127 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_INVITE); 140 struct GNUNET_MESSENGER_Message *message = create_message (
141 GNUNET_MESSENGER_KIND_INVITE);
128 142
129 if (!message) 143 if (! message)
130 return NULL; 144 return NULL;
131 145
132 GNUNET_memcpy(&(message->body.invite.door), door, sizeof(struct GNUNET_PeerIdentity)); 146 GNUNET_memcpy (&(message->body.invite.door), door, sizeof(struct
133 GNUNET_memcpy(&(message->body.invite.key), key, sizeof(struct GNUNET_HashCode)); 147 GNUNET_PeerIdentity));
148 GNUNET_memcpy (&(message->body.invite.key), key, sizeof(struct
149 GNUNET_HashCode));
134 150
135 return message; 151 return message;
136} 152}
137 153
154
138struct GNUNET_MESSENGER_Message* 155struct GNUNET_MESSENGER_Message*
139create_message_text (const char *text) 156create_message_text (const char *text)
140{ 157{
141 if (!text) 158 if (! text)
142 return NULL; 159 return NULL;
143 160
144 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_TEXT); 161 struct GNUNET_MESSENGER_Message *message = create_message (
162 GNUNET_MESSENGER_KIND_TEXT);
145 163
146 if (!message) 164 if (! message)
147 return NULL; 165 return NULL;
148 166
149 message->body.text.text = GNUNET_strdup(text); 167 message->body.text.text = GNUNET_strdup (text);
150 return message; 168 return message;
151} 169}
152 170
171
153struct GNUNET_MESSENGER_Message* 172struct GNUNET_MESSENGER_Message*
154create_message_delete (const struct GNUNET_HashCode *hash, 173create_message_delete (const struct GNUNET_HashCode *hash,
155 const struct GNUNET_TIME_Relative delay) 174 const struct GNUNET_TIME_Relative delay)
156{ 175{
157 if (!hash) 176 if (! hash)
158 return NULL; 177 return NULL;
159 178
160 struct GNUNET_MESSENGER_Message *message = create_message (GNUNET_MESSENGER_KIND_DELETE); 179 struct GNUNET_MESSENGER_Message *message = create_message (
180 GNUNET_MESSENGER_KIND_DELETE);
161 181
162 if (!message) 182 if (! message)
163 return NULL; 183 return NULL;
164 184
165 GNUNET_memcpy(&(message->body.deletion.hash), hash, sizeof(struct GNUNET_HashCode)); 185 GNUNET_memcpy (&(message->body.deletion.hash), hash, sizeof(struct
186 GNUNET_HashCode));
166 message->body.deletion.delay = GNUNET_TIME_relative_hton (delay); 187 message->body.deletion.delay = GNUNET_TIME_relative_hton (delay);
167 188
168 return message; 189 return message;