1 /*
2 Copyright (c) 2010-2020 Roger Light <roger@atchoo.org>
3
4 All rights reserved. This program and the accompanying materials
5 are made available under the terms of the Eclipse Public License 2.0
6 and Eclipse Distribution License v1.0 which accompany this distribution.
7
8 The Eclipse Public License is available at
9 https://www.eclipse.org/legal/epl-2.0/
10 and the Eclipse Distribution License is available at
11 http://www.eclipse.org/org/documents/edl-v10.php.
12
13 SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
14
15 Contributors:
16 Roger Light - initial implementation and documentation.
17 */
18
19 #include "config.h"
20
21 #include <string.h>
22
23 #include "mosquitto.h"
24 #include "mosquitto_internal.h"
25 #include "memory_mosq.h"
26 #include "messages_mosq.h"
27 #include "mqtt_protocol.h"
28 #include "net_mosq.h"
29 #include "packet_mosq.h"
30 #include "send_mosq.h"
31 #include "util_mosq.h"
32
33
mosquitto_publish(struct mosquitto * mosq,int * mid,const char * topic,int payloadlen,const void * payload,int qos,bool retain)34 int mosquitto_publish(struct mosquitto *mosq, int *mid, const char *topic, int payloadlen, const void *payload, int qos, bool retain)
35 {
36 return mosquitto_publish_v5(mosq, mid, topic, payloadlen, payload, qos, retain, NULL);
37 }
38
mosquitto_publish_v5(struct mosquitto * mosq,int * mid,const char * topic,int payloadlen,const void * payload,int qos,bool retain,const mosquitto_property * properties)39 int mosquitto_publish_v5(struct mosquitto *mosq, int *mid, const char *topic, int payloadlen, const void *payload, int qos, bool retain, const mosquitto_property *properties)
40 {
41 struct mosquitto_message_all *message;
42 uint16_t local_mid;
43 const mosquitto_property *p;
44 const mosquitto_property *outgoing_properties = NULL;
45 mosquitto_property *properties_copy = NULL;
46 mosquitto_property local_property;
47 bool have_topic_alias;
48 int rc;
49 size_t tlen = 0;
50 uint32_t remaining_length;
51
52 if(!mosq || qos<0 || qos>2) return MOSQ_ERR_INVAL;
53 if(mosq->protocol != mosq_p_mqtt5 && properties) return MOSQ_ERR_NOT_SUPPORTED;
54 if(qos > mosq->max_qos) return MOSQ_ERR_QOS_NOT_SUPPORTED;
55
56 if(!mosq->retain_available){
57 retain = false;
58 }
59
60 if(properties){
61 if(properties->client_generated){
62 outgoing_properties = properties;
63 }else{
64 memcpy(&local_property, properties, sizeof(mosquitto_property));
65 local_property.client_generated = true;
66 local_property.next = NULL;
67 outgoing_properties = &local_property;
68 }
69 rc = mosquitto_property_check_all(CMD_PUBLISH, outgoing_properties);
70 if(rc) return rc;
71 }
72
73 if(!topic || STREMPTY(topic)){
74 if(topic) topic = NULL;
75
76 if(mosq->protocol == mosq_p_mqtt5){
77 p = outgoing_properties;
78 have_topic_alias = false;
79 while(p){
80 if(p->identifier == MQTT_PROP_TOPIC_ALIAS){
81 have_topic_alias = true;
82 break;
83 }
84 p = p->next;
85 }
86 if(have_topic_alias == false){
87 return MOSQ_ERR_INVAL;
88 }
89 }else{
90 return MOSQ_ERR_INVAL;
91 }
92 }else{
93 tlen = strlen(topic);
94 if(mosquitto_validate_utf8(topic, (int)tlen)) return MOSQ_ERR_MALFORMED_UTF8;
95 if(payloadlen < 0 || payloadlen > (int)MQTT_MAX_PAYLOAD) return MOSQ_ERR_PAYLOAD_SIZE;
96 if(mosquitto_pub_topic_check(topic) != MOSQ_ERR_SUCCESS){
97 return MOSQ_ERR_INVAL;
98 }
99 }
100
101 if(mosq->maximum_packet_size > 0){
102 remaining_length = 1 + 2+(uint32_t)tlen + (uint32_t)payloadlen + property__get_length_all(outgoing_properties);
103 if(qos > 0){
104 remaining_length++;
105 }
106 if(packet__check_oversize(mosq, remaining_length)){
107 return MOSQ_ERR_OVERSIZE_PACKET;
108 }
109 }
110
111 local_mid = mosquitto__mid_generate(mosq);
112 if(mid){
113 *mid = local_mid;
114 }
115
116 if(qos == 0){
117 return send__publish(mosq, local_mid, topic, (uint32_t)payloadlen, payload, (uint8_t)qos, retain, false, outgoing_properties, NULL, 0);
118 }else{
119 if(outgoing_properties){
120 rc = mosquitto_property_copy_all(&properties_copy, outgoing_properties);
121 if(rc) return rc;
122 }
123 message = mosquitto__calloc(1, sizeof(struct mosquitto_message_all));
124 if(!message){
125 mosquitto_property_free_all(&properties_copy);
126 return MOSQ_ERR_NOMEM;
127 }
128
129 message->next = NULL;
130 message->timestamp = mosquitto_time();
131 message->msg.mid = local_mid;
132 if(topic){
133 message->msg.topic = mosquitto__strdup(topic);
134 if(!message->msg.topic){
135 message__cleanup(&message);
136 mosquitto_property_free_all(&properties_copy);
137 return MOSQ_ERR_NOMEM;
138 }
139 }
140 if(payloadlen){
141 message->msg.payloadlen = payloadlen;
142 message->msg.payload = mosquitto__malloc((unsigned int)payloadlen*sizeof(uint8_t));
143 if(!message->msg.payload){
144 message__cleanup(&message);
145 mosquitto_property_free_all(&properties_copy);
146 return MOSQ_ERR_NOMEM;
147 }
148 memcpy(message->msg.payload, payload, (uint32_t)payloadlen*sizeof(uint8_t));
149 }else{
150 message->msg.payloadlen = 0;
151 message->msg.payload = NULL;
152 }
153 message->msg.qos = (uint8_t)qos;
154 message->msg.retain = retain;
155 message->dup = false;
156 message->properties = properties_copy;
157
158 pthread_mutex_lock(&mosq->msgs_out.mutex);
159 message->state = mosq_ms_invalid;
160 rc = message__queue(mosq, message, mosq_md_out);
161 pthread_mutex_unlock(&mosq->msgs_out.mutex);
162 return rc;
163 }
164 }
165
166
mosquitto_subscribe(struct mosquitto * mosq,int * mid,const char * sub,int qos)167 int mosquitto_subscribe(struct mosquitto *mosq, int *mid, const char *sub, int qos)
168 {
169 return mosquitto_subscribe_multiple(mosq, mid, 1, (char *const *const)&sub, qos, 0, NULL);
170 }
171
172
mosquitto_subscribe_v5(struct mosquitto * mosq,int * mid,const char * sub,int qos,int options,const mosquitto_property * properties)173 int mosquitto_subscribe_v5(struct mosquitto *mosq, int *mid, const char *sub, int qos, int options, const mosquitto_property *properties)
174 {
175 return mosquitto_subscribe_multiple(mosq, mid, 1, (char *const *const)&sub, qos, options, properties);
176 }
177
178
mosquitto_subscribe_multiple(struct mosquitto * mosq,int * mid,int sub_count,char * const * const sub,int qos,int options,const mosquitto_property * properties)179 int mosquitto_subscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count, char *const *const sub, int qos, int options, const mosquitto_property *properties)
180 {
181 const mosquitto_property *outgoing_properties = NULL;
182 mosquitto_property local_property;
183 int i;
184 int rc;
185 uint32_t remaining_length = 0;
186 int slen;
187
188 if(!mosq || !sub_count || !sub) return MOSQ_ERR_INVAL;
189 if(mosq->protocol != mosq_p_mqtt5 && properties) return MOSQ_ERR_NOT_SUPPORTED;
190 if(qos < 0 || qos > 2) return MOSQ_ERR_INVAL;
191 if((options & 0x30) == 0x30 || (options & 0xC0) != 0) return MOSQ_ERR_INVAL;
192 if(mosq->sock == INVALID_SOCKET) return MOSQ_ERR_NO_CONN;
193
194 if(properties){
195 if(properties->client_generated){
196 outgoing_properties = properties;
197 }else{
198 memcpy(&local_property, properties, sizeof(mosquitto_property));
199 local_property.client_generated = true;
200 local_property.next = NULL;
201 outgoing_properties = &local_property;
202 }
203 rc = mosquitto_property_check_all(CMD_SUBSCRIBE, outgoing_properties);
204 if(rc) return rc;
205 }
206
207 for(i=0; i<sub_count; i++){
208 if(mosquitto_sub_topic_check(sub[i])) return MOSQ_ERR_INVAL;
209 slen = (int)strlen(sub[i]);
210 if(mosquitto_validate_utf8(sub[i], slen)) return MOSQ_ERR_MALFORMED_UTF8;
211 remaining_length += 2+(uint32_t)slen + 1;
212 }
213
214 if(mosq->maximum_packet_size > 0){
215 remaining_length += 2 + property__get_length_all(outgoing_properties);
216 if(packet__check_oversize(mosq, remaining_length)){
217 return MOSQ_ERR_OVERSIZE_PACKET;
218 }
219 }
220 if(mosq->protocol == mosq_p_mqtt311 || mosq->protocol == mosq_p_mqtt31){
221 options = 0;
222 }
223
224 return send__subscribe(mosq, mid, sub_count, sub, qos|options, outgoing_properties);
225 }
226
227
mosquitto_unsubscribe(struct mosquitto * mosq,int * mid,const char * sub)228 int mosquitto_unsubscribe(struct mosquitto *mosq, int *mid, const char *sub)
229 {
230 return mosquitto_unsubscribe_multiple(mosq, mid, 1, (char *const *const)&sub, NULL);
231 }
232
mosquitto_unsubscribe_v5(struct mosquitto * mosq,int * mid,const char * sub,const mosquitto_property * properties)233 int mosquitto_unsubscribe_v5(struct mosquitto *mosq, int *mid, const char *sub, const mosquitto_property *properties)
234 {
235 return mosquitto_unsubscribe_multiple(mosq, mid, 1, (char *const *const)&sub, properties);
236 }
237
mosquitto_unsubscribe_multiple(struct mosquitto * mosq,int * mid,int sub_count,char * const * const sub,const mosquitto_property * properties)238 int mosquitto_unsubscribe_multiple(struct mosquitto *mosq, int *mid, int sub_count, char *const *const sub, const mosquitto_property *properties)
239 {
240 const mosquitto_property *outgoing_properties = NULL;
241 mosquitto_property local_property;
242 int rc;
243 int i;
244 uint32_t remaining_length = 0;
245 int slen;
246
247 if(!mosq) return MOSQ_ERR_INVAL;
248 if(mosq->protocol != mosq_p_mqtt5 && properties) return MOSQ_ERR_NOT_SUPPORTED;
249 if(mosq->sock == INVALID_SOCKET) return MOSQ_ERR_NO_CONN;
250
251 if(properties){
252 if(properties->client_generated){
253 outgoing_properties = properties;
254 }else{
255 memcpy(&local_property, properties, sizeof(mosquitto_property));
256 local_property.client_generated = true;
257 local_property.next = NULL;
258 outgoing_properties = &local_property;
259 }
260 rc = mosquitto_property_check_all(CMD_UNSUBSCRIBE, outgoing_properties);
261 if(rc) return rc;
262 }
263
264 for(i=0; i<sub_count; i++){
265 if(mosquitto_sub_topic_check(sub[i])) return MOSQ_ERR_INVAL;
266 slen = (int)strlen(sub[i]);
267 if(mosquitto_validate_utf8(sub[i], slen)) return MOSQ_ERR_MALFORMED_UTF8;
268 remaining_length += 2U + (uint32_t)slen;
269 }
270
271 if(mosq->maximum_packet_size > 0){
272 remaining_length += 2U + property__get_length_all(outgoing_properties);
273 if(packet__check_oversize(mosq, remaining_length)){
274 return MOSQ_ERR_OVERSIZE_PACKET;
275 }
276 }
277
278 return send__unsubscribe(mosq, mid, sub_count, sub, outgoing_properties);
279 }
280
281