int main(int argc, char** argv)
{
int rc = 0;
if (argc < 2)
usage();
char* topic = argv[1];
if (strchr(topic, '#') || strchr(topic, '+'))
opts.showtopics = 1;
if (opts.showtopics)
printf("topic is %s\n", topic);
getopts(argc, argv);
IPStack ipstack = IPStack();
MQTT::Client<IPStack, Countdown, 1000> client = MQTT::Client<IPStack, Countdown, 1000>(ipstack);
signal(SIGINT, cfinish);
signal(SIGTERM, cfinish);
MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
data.willFlag = 0;
data.MQTTVersion = 3;
data.clientID.cstring = opts.clientid;
data.username.cstring = opts.username;
data.password.cstring = opts.password;
data.keepAliveInterval = 10;
data.cleansession = 1;
printf("will flag %d\n", data.willFlag);
myconnect(ipstack, client, data);
rc = client.subscribe(topic, opts.qos, messageArrived);
printf("Subscribed %d\n", rc);
while (!toStop)
{
client.yield(1000);
//if (!client.isconnected)
// myconnect(ipstack, client, data);
}
printf("Stopping\n");
rc = client.disconnect();
ipstack.disconnect();
return 0;
}
TCP::TCP(IPStack& inet) :
inet_(inet),
listeners_(),
connections_(),
writeq(),
used_ports(),
MAX_SEG_LIFETIME(30s)
{
inet.on_transmit_queue_available(transmit_avail_delg::from<TCP,&TCP::process_writeq>(this));
}
void Disconnect()
{
rc = client.disconnect();
if (rc != 0)
printf("rc from disconnect was %d\n", rc);
else
printf("Disconnected now.", rc);
ipStackVar.disconnect();
}
TCP::TCP(IPStack& inet, bool smp_enable) :
inet_{inet},
listeners_(),
connections_(),
ports_(inet.tcp_ports()),
writeq(),
max_seg_lifetime_{default_msl}, // 30s
win_size_{default_ws_window_size}, // 8096*1024
wscale_{default_window_scaling}, // 5
timestamps_{default_timestamps}, // true
dack_timeout_{default_dack_timeout}, // 40ms
max_syn_backlog_{default_max_syn_backlog} // 64
{
Expects(wscale_ <= 14 && "WScale factor cannot exceed 14");
Expects(win_size_ <= 0x40000000 && "Invalid size");
this->cpu_id = SMP::cpu_id();
this->smp_enabled = smp_enable;
std::string stat_prefix;
if (this->smp_enabled == false)
{
inet.on_transmit_queue_available({this, &TCP::process_writeq});
stat_prefix = inet.ifname();
}
else
{
SMP::global_lock();
inet.on_transmit_queue_available({this, &TCP::smp_process_writeq});
SMP::global_unlock();
stat_prefix = inet.ifname() + ".cpu" + std::to_string(this->cpu_id);
}
bytes_rx_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.rx").get_uint64();
bytes_tx_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.tx").get_uint64();
packets_rx_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.packets_rx").get_uint64();
packets_tx_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.packets_tx").get_uint64();
incoming_connections_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.conn_incoming").get_uint64();
outgoing_connections_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.conn_outgoing").get_uint64();
connection_attempts_ = &Statman::get().create(Stat::UINT64, stat_prefix + ".tcp.conn_attempts").get_uint64();
packets_dropped_ = &Statman::get().create(Stat::UINT32, stat_prefix + ".tcp.dropped").get_uint32();
}
void myconnect(IPStack& ipstack, MQTT::Client<IPStack, Countdown, 1000>& client, MQTTPacket_connectData& data)
{
printf("Connecting to %s:%d\n", opts.host, opts.port);
int rc = ipstack.connect(opts.host, opts.port);
if (rc != 0)
printf("rc from TCP connect is %d\n", rc);
rc = client.connect(data);
if (rc != 0)
{
printf("Failed to connect, return code %d\n", rc);
exit(-1);
}
printf("Connected\n");
}
void InitializeMQTTCommunication()
{
version = 0.3;
printf("Version is %f\n", version);
const char* hostname = "52.207.148.30"; // iot.eclipse.org
printf("Connecting to %s:%d\n", hostname, PORT_NUM);
rc = ipStackVar.connect(hostname, PORT_NUM);
if (rc != 0)
printf("rc from TCP connect is %d\n", rc);
printf("MQTT connecting\n");
MQTTPacket_connectData data = MQTTPacket_connectData_initializer;
data.MQTTVersion = 3;
data.clientID.cstring = (char*)"mbed-icraggs";
rc = client.connect(data);
if (rc != 0)
printf("rc from MQTT connect is %d\n", rc);
printf("MQTT connected\n");
}
int main(int argc, char* argv[])
{
IPStack ipstack = IPStack();
float version = 0.3;
const char* topic = "mbed-sample";
printf("Version is %f\n", version);
MQTT::Client<IPStack, Countdown> client = MQTT::Client<IPStack, Countdown>(ipstack);
client.setConnectionLostHandler(connect);
MQTT::Client<IPStack, Countdown>::connectionLostInfo info = {&client, &ipstack};
int rc = connect(&info);
rc = client.subscribe(topic, MQTT::QOS2, messageArrived);
if (rc != 0)
printf("rc from MQTT subscribe is %d\n", rc);
MQTT::Message message;
// QoS 0
char buf[100];
sprintf(buf, "Hello World! QoS 0 message from app version %f", version);
message.qos = MQTT::QOS0;
message.retained = false;
message.dup = false;
message.payload = (void*)buf;
message.payloadlen = strlen(buf)+1;
rc = client.publish(topic, &message);
while (arrivedcount == 0)
client.yield(100);
// QoS 1
printf("Now QoS 1\n");
sprintf(buf, "Hello World! QoS 1 message from app version %f", version);
message.qos = MQTT::QOS1;
message.payloadlen = strlen(buf)+1;
rc = client.publish(topic, &message);
while (arrivedcount == 1)
client.yield(100);
// QoS 2
sprintf(buf, "Hello World! QoS 2 message from app version %f", version);
message.qos = MQTT::QOS2;
message.payloadlen = strlen(buf)+1;
rc = client.publish(topic, &message);
while (arrivedcount == 2)
client.yield(100);
rc = client.unsubscribe(topic);
if (rc != 0)
printf("rc from unsubscribe was %d\n", rc);
rc = client.disconnect();
if (rc != 0)
printf("rc from disconnect was %d\n", rc);
ipstack.disconnect();
printf("Finishing with %d messages received\n", arrivedcount);
return 0;
}
