1

/**************************************************************************

     2

*

     3

* Copyright (C) 2006 Steve Karg <skarg@users.sourceforge.net>

     4

* Copyright (C) 2017 Mario de Sousa <msousa@fe.up.pt>

     5

*

     6

* Permission is hereby granted, free of charge, to any person obtaining

     7

* a copy of this software and associated documentation files (the

     8

* "Software"), to deal in the Software without restriction, including

     9

* without limitation the rights to use, copy, modify, merge, publish,

    10

* distribute, sublicense, and/or sell copies of the Software, and to

    11

* permit persons to whom the Software is furnished to do so, subject to

    12

* the following conditions:

    13

*

    14

* The above copyright notice and this permission notice shall be included

    15

* in all copies or substantial portions of the Software.

    16

*

    17

* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    18

* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    19

* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    20

* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY

    21

* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,

    22

* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE

    23

* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    24

*

    25

*********************************************************************/

    26

#include <stddef.h>

    27

#include <stdint.h>

    28

#include <stdio.h>

    29

#include <stdlib.h>

    30

#include <signal.h>

    31

#include <time.h>

    32

#include <inttypes.h>  // uint32_t, ..., PRIu32, ...

    33

    34

#include "config_bacnet_for_beremiz_%(locstr)s.h"     /* the custom configuration for beremiz pluginh  */

    35

#include "server_%(locstr)s.h"

    36

#include "address.h"

    37

#include "bacdef.h"

    38

#include "handlers.h"

    39

#include "client.h"

    40

#include "dlenv.h"

    41

#include "bacdcode.h"

    42

#include "npdu.h"

    43

#include "apdu.h"

    44

#include "iam.h"

    45

#include "tsm.h"

    46

#include "datalink.h"

    47

#include "dcc.h"

    48

#include "getevent.h"

    49

#include "net.h"

    50

#include "txbuf.h"

    51

#include "version.h"

    52

#include "timesync.h"

    53

    54

    55

    56

    57

    58

    59

/* A utility function used by most (all?) implementations of BACnet Objects */

    60

/* Adds to Prop_List all entries in Prop_List_XX that are not

    61

 * PROP_OBJECT_IDENTIFIER, PROP_OBJECT_NAME, PROP_OBJECT_TYPE, PROP_PROPERTY_LIST

    62

 * and returns the number of elements that were added

    63

 */

    64

int BACnet_Init_Properties_List(

    65

          int *Prop_List, 

    66

    const int *Prop_List_XX) {

    67

    68

    unsigned int i = 0;

    69

    unsigned int j = 0;

    70

    71

    for (j = 0; Prop_List_XX[j] >= 0; j++)

    72

        // Add any propety, except for the following 4 which should not be included

    73

        // in the Property_List property array.

    74

        //  (see ASHRAE 135-2016, for example section 12.4.34)

    75

        if ((Prop_List_XX[j] != PROP_OBJECT_IDENTIFIER) &&

    76

            (Prop_List_XX[j] != PROP_OBJECT_NAME)       &&

    77

            (Prop_List_XX[j] != PROP_OBJECT_TYPE)       &&

    78

            (Prop_List_XX[j] != PROP_PROPERTY_LIST)) {

    79

            Prop_List[i] = Prop_List_XX[j];

    80

            i++;

    81

        }

    82

    Prop_List[i] = -1; // marks the end of the list!

    83

    return i;

    84

}

    85

    86

    87

    88

    89

    90

    91

int BACnet_encode_character_string(uint8_t *apdu, const char *str) {

    92

    BACNET_CHARACTER_STRING   char_string;

    93

    characterstring_init_ansi(&char_string, str);

    94

    /* FIXME: this might go beyond MAX_APDU length! */

    95

    return encode_application_character_string(apdu, &char_string);

    96

}

    97

    98

/* macro that always returns false.

    99

 * To be used as the 'test_null' parameter to the BACnet_encode_array macro

   100

 * in situations where we should never encode_null() values.

   101

 */

   102

#define retfalse(x) (false)

   103

   104

#define BACnet_encode_array(array, array_len, test_null, encode_function)                  \

   105

{                                                                                           \

   106

    uint8_t *apdu = NULL;                                                                   \

   107

    apdu = rpdata->application_data;                                                        \

   108

                                                                                            \

   109

    switch (rpdata->array_index) {                                                          \

   110

      case 0: /* Array element zero is the number of elements in the array */               \

   111

        apdu_len = encode_application_unsigned(&apdu[0], array_len);                        \

   112

        break;                                                                              \

   113

      case BACNET_ARRAY_ALL: {                                                              \

   114

        /* if no index was specified, then try to encode the entire list */                 \

   115

        unsigned i = 0;                                                                     \

   116

        apdu_len   = 0;                                                                     \

   117

        for (i = 0; i < array_len; i++) {                                                   \

   118

            /* FIXME: this might go beyond MAX_APDU length! */                              \

   119

            if (!test_null(array[i]))                                                       \

   120

                  apdu_len += encode_function        (&apdu[apdu_len], array[i]);           \

   121

            else  apdu_len += encode_application_null(&apdu[apdu_len]);                     \

   122

            /* return error if it does not fit in the APDU */                               \

   123

            if (apdu_len >= MAX_APDU) {                                                     \

   124

                rpdata->error_class = ERROR_CLASS_SERVICES;                                 \

   125

                rpdata->error_code = ERROR_CODE_NO_SPACE_FOR_OBJECT;                        \

   126

                apdu_len = BACNET_STATUS_ERROR;                                             \

   127

                break; /* for(;;) */                                                        \

   128

            }                                                                               \

   129

        }                                                                                   \

   130

        break;                                                                              \

   131

      }                                                                                     \

   132

      default:                                                                              \

   133

        if (rpdata->array_index <= array_len) {                                             \

   134

            if (!test_null(array[rpdata->array_index - 1]))                                 \

   135

                  apdu_len += encode_function(&apdu[0], array[rpdata->array_index - 1]);    \

   136

            else  apdu_len += encode_application_null(&apdu[0]);                            \

   137

        } else {                                                                            \

   138

            rpdata->error_class = ERROR_CLASS_PROPERTY;                                     \

   139

            rpdata->error_code = ERROR_CODE_INVALID_ARRAY_INDEX;                            \

   140

            apdu_len = BACNET_STATUS_ERROR;                                                 \

   141

        }                                                                                   \

   142

        break;                                                                              \

   143

    } /* switch() */                                                                        \

   144

}

   145

   146

   147

/* include the device object */

   148

#include "device_%(locstr)s.c"

   149

#include "ai_%(locstr)s.c"

   150

#include "ao_%(locstr)s.c"

   151

#include "av_%(locstr)s.c"

   152

#include "bi_%(locstr)s.c"

   153

#include "bo_%(locstr)s.c"

   154

#include "bv_%(locstr)s.c"

   155

#include "msi_%(locstr)s.c"

   156

#include "mso_%(locstr)s.c"

   157

#include "msv_%(locstr)s.c"

   158

   159

   160

/** Buffer used for receiving */

   161

static uint8_t Rx_Buf[MAX_MPDU] = { 0 };

   162

   163

   164

   165

   166

/*******************************************************/

   167

/* BACnet Service Handlers taylored to Beremiz plugin  */ 

   168

/*******************************************************/

   169

   170

static void BACNET_show_date_time(

   171

    BACNET_DATE * bdate,

   172

    BACNET_TIME * btime)

   173

{

   174

    /* show the date received */

   175

    fprintf(stderr, "%%u", (unsigned) bdate->year);

   176

    fprintf(stderr, "/%%u", (unsigned) bdate->month);

   177

    fprintf(stderr, "/%%u", (unsigned) bdate->day);

   178

    /* show the time received */

   179

    fprintf(stderr, " %%02u", (unsigned) btime->hour);

   180

    fprintf(stderr, ":%%02u", (unsigned) btime->min);

   181

    fprintf(stderr, ":%%02u", (unsigned) btime->sec);

   182

    fprintf(stderr, ".%%02u", (unsigned) btime->hundredths);

   183

    fprintf(stderr, "\r\n");

   184

}

   185

   186

static time_t __timegm(struct tm *new_time) {

   187

    time_t     sec =  mktime(new_time);  /* assume new_time is in local time */

   188

   189

    /* sec will be an aproximation of the correct value. 

   190

     * We must now fix this with the current difference

   191

     * between UTC and localtime.

   192

     * 

   193

     * WARNING: The following algorithm to determine the current

   194

     *          difference between local time and UTC will not 

   195

     *          work if each value (lcl and utc) falls on a different

   196

     *          side of a change to/from DST.

   197

     *          For example, assume a change to DST is made at 12h00 

   198

     *          of day X. The following algorithm does not work if:

   199

     *            - lcl falls before 12h00 of day X

   200

     *            - utc falls after  12h00 of day X

   201

     */

   202

    struct  tm lcl = *localtime(&sec); // lcl will be == new_time

   203

    struct  tm utc = *gmtime   (&sec);

   204

   205

    if (lcl.tm_isdst == 1)  utc.tm_isdst = 1;

   206

   207

    time_t sec_lcl =  mktime(&lcl);

   208

    time_t sec_utc =  mktime(&utc);

   209

   210

    /* difference in seconds between localtime and utc */

   211

    time_t sec_dif = sec_lcl - sec_utc;

   212

    return sec + sec_dif;

   213

}

   214

   215

   216

static void BACNET_set_date_time(

   217

    BACNET_DATE * bdate,

   218

    BACNET_TIME * btime,

   219

    int utc /* set to > 0 if date & time in UTC */)

   220

{

   221

    struct tm       brokendown_time;

   222

    time_t          seconds = 0;

   223

    struct timespec ts;

   224

   225

    brokendown_time.tm_sec   = btime->sec;        /* seconds 0..60    */

   226

    brokendown_time.tm_min   = btime->min;        /* minutes 0..59    */

   227

    brokendown_time.tm_hour  = btime->hour;       /* hours   0..23    */

   228

    brokendown_time.tm_mday  = bdate->day;        /* day of the month 1..31 */

   229

    brokendown_time.tm_mon   = bdate->month-1;    /* month 0..11      */

   230

    brokendown_time.tm_year  = bdate->year-1900;  /* years since 1900 */

   231

//  brokendown_time.tm_wday  = ;                  /* day of the week  */

   232

//  brokendown_time.tm_yday  = ;                  /* day in the year  */

   233

    brokendown_time.tm_isdst = -1;                /* daylight saving time (-1 => unknown) */

   234

   235

    // Tranform time into format -> 'seconds since epoch'

   236

    /* WARNING: timegm() is a non standard GNU extension.

   237

     *          If you do not have it on your build system then consider

   238

     *          finding the source code for timegm() (it is LGPL) from GNU

   239

     *          C library and copying it here 

   240

     *          (e.g. https://code.woboq.org/userspace/glibc/time/timegm.c.html)

   241

     *          Another alternative is to use the fundion __timegm() above,

   242

     *          which will mostly work but may have errors when the time being 

   243

     *          converted is close to the time in the year when changing 

   244

     *          to/from DST (daylight saving time)

   245

     */

   246

    if (utc > 0) seconds = timegm(&brokendown_time);    

   247

    else         seconds = mktime(&brokendown_time);

   248

   249

    ts.tv_sec  = seconds;

   250

    ts.tv_nsec = btime->hundredths*10*1000*1000;

   251

   252

//  fprintf(stderr, "clock_settime() s=%%ul,  ns=%%u\n", ts.tv_sec, ts.tv_nsec);

   253

    clock_settime(CLOCK_REALTIME, &ts); 

   254

//  clock_gettime(CLOCK_REALTIME, &ts); 

   255

//  fprintf(stderr, "clock_gettime() s=%%ul,  ns=%%u\n", ts.tv_sec, ts.tv_nsec);

   256

}

   257

   258

   259

   260

void BACnet_handler_timesync(

   261

    uint8_t * service_request,

   262

    uint16_t service_len,

   263

    BACNET_ADDRESS * src)

   264

{

   265

    int len = 0;

   266

    BACNET_DATE bdate;

   267

    BACNET_TIME btime;

   268

   269

    (void) src;

   270

    (void) service_len;

   271

    len =

   272

        timesync_decode_service_request(service_request, service_len, &bdate, &btime);

   273

    if (len > 0) {

   274

        fprintf(stderr, "BACnet plugin: Received TimeSyncronization Request -> ");

   275

        BACNET_show_date_time(&bdate, &btime);

   276

        /* set the time */

   277

        BACNET_set_date_time(&bdate, &btime, 0 /* time in local time */);

   278

    }

   279

   280

    return;

   281

}

   282

   283

void BACnet_handler_timesync_utc(

   284

    uint8_t * service_request,

   285

    uint16_t service_len,

   286

    BACNET_ADDRESS * src)

   287

{

   288

    int len = 0;

   289

    BACNET_DATE bdate;

   290

    BACNET_TIME btime;

   291

   292

    (void) src;

   293

    (void) service_len;

   294

    len =

   295

        timesync_decode_service_request(service_request, service_len, &bdate, &btime);

   296

    if (len > 0) {

   297

        fprintf(stderr, "BACnet plugin: Received TimeSyncronizationUTC Request -> ");

   298

        BACNET_show_date_time(&bdate, &btime);

   299

        /* set the time */

   300

        BACNET_set_date_time(&bdate, &btime, 1 /* time in UTC */);

   301

    }

   302

   303

    return;

   304

}

   305

   306

   307

   308

/**********************************************/

   309

/** Initialize the handlers we will utilize. **/

   310

/**********************************************/

   311

/*

   312

 * TLDR: The functions that will create the __Resp.__ messages.

   313

 * 

   314

 * The service handlers are the functions that will respond to BACnet requests this device receives.

   315

 * In essence, the service handlers will create and send the Resp. (Response) messages

   316

 * of the Req. -> Ind. -> Resp. -> Conf. service sequence defined in OSI

   317

 * (Request, Indication, Response, Confirmation)

   318

 * 

   319

 */

   320

static int Init_Service_Handlers(

   321

    void)

   322

{

   323

    /* set the handler for all the services we don't implement */

   324

    /* It is required to send the proper reject message... */

   325

    apdu_set_unrecognized_service_handler_handler(handler_unrecognized_service);

   326

   327

    /* Set the handlers for any unconfirmed services that we support. */

   328

    apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_IS,  // DM-DDB-B - Dynamic Device Binding B (Resp.)

   329

                                   handler_who_is);           //            (see ASHRAE 135-2016, section K5.1 and K5.2)

   330

//  apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_I_AM,    // DM-DDB-A - Dynamic Device Binding A (Resp.)

   331

//                                 handler_i_am_bind);        //            Responding to I_AM requests is for clients (A)!

   332

//                                                            //            (see ASHRAE 135-2016, section K5.1 and K5.2)

   333

    apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_WHO_HAS, // DM-DOB-B - Dynamic Object Binding B (Resp.)

   334

                                   handler_who_has);          //            (see ASHRAE 135-2016, section K5.3 and K5.4)

   335

//  apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_I_HAVE,  // DM-DOB-A - Dynamic Object Binding A (Resp.)

   336

//                                 handler_i_have);           //            Responding to I_HAVE requests is for clients (A)!

   337

//                                                            //            (see ASHRAE 135-2016, section K5.3 and K5.4)

   338

    apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_UTC_TIME_SYNCHRONIZATION, // DM-UTC-B -UTCTimeSynchronization-B (Resp.)

   339

                                 BACnet_handler_timesync_utc);                 //            (see ASHRAE 135-2016, section K5.14)

   340

    apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_TIME_SYNCHRONIZATION,     // DM-TS-B - TimeSynchronization-B (Resp.)

   341

                                 BACnet_handler_timesync);                     //            (see ASHRAE 135-2016, section K5.12)

   342

   343

    /* Set the handlers for any confirmed services that we support. */

   344

    apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROPERTY,      // DS-RP-B - Read Property B (Resp.)

   345

                                 handler_read_property);             //            (see ASHRAE 135-2016, section K1.2)

   346

//  apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_PROP_MULTIPLE, // DS-RPM-B -Read Property Multiple-B (Resp.)

   347

//                               handler_read_property_multiple);    //            (see ASHRAE 135-2016, section K1.4)

   348

    apdu_set_confirmed_handler(SERVICE_CONFIRMED_WRITE_PROPERTY,     // DS-WP-B - Write Property B (Resp.)

   349

                                 handler_write_property);            //            (see ASHRAE 135-2016, section K1.8)

   350

//  apdu_set_confirmed_handler(SERVICE_CONFIRMED_WRITE_PROP_MULTIPLE,// DS-WPM-B -Write Property Multiple B (Resp.)

   351

//                               handler_write_property_multiple);   //            (see ASHRAE 135-2016, section K1.10)

   352

//  apdu_set_confirmed_handler(SERVICE_CONFIRMED_READ_RANGE,

   353

//                               handler_read_range);

   354

//  apdu_set_confirmed_handler(SERVICE_CONFIRMED_REINITIALIZE_DEVICE,

   355

//                               handler_reinitialize_device);

   356

   357

//  apdu_set_confirmed_handler(SERVICE_CONFIRMED_SUBSCRIBE_COV,

   358

//                               handler_cov_subscribe);

   359

//  apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_COV_NOTIFICATION,

   360

//                               handler_ucov_notification);

   361

    /* handle communication so we can shutup when asked */

   362

    apdu_set_confirmed_handler(SERVICE_CONFIRMED_DEVICE_COMMUNICATION_CONTROL, // DM-DCC-B - Device Communication Control B

   363

                                 handler_device_communication_control);        //            (see ASHRAE 135-2016, section K5.6)

   364

//  /* handle the data coming back from private requests */

   365

//  apdu_set_unconfirmed_handler(SERVICE_UNCONFIRMED_PRIVATE_TRANSFER,

   366

//                               handler_unconfirmed_private_transfer);

   367

   368

    // success

   369

    return 0;

   370

}

   371

   372

   373

   374

static int Init_Network_Interface(

   375

    const char *interface,    // for linux:   /dev/eth0, /dev/eth1, /dev/wlan0, ...

   376

                              // for windows: 192.168.0.1 (IP addr. of interface)

   377

                              // NULL => use default!

   378

    const char *port,         // Port the server will listen on. (NULL => use default)

   379

    const char *apdu_timeout, // (NULL => use default)

   380

    const char *apdu_retries  // (NULL => use default)

   381

   )

   382

{

   383

    char datalink_layer[4];

   384

   385

    strcpy(datalink_layer, "BIP"); // datalink_set() does not accpet const char *, so we copy it...

   386

//  BIP_Debug = true;

   387

   388

    if (port != NULL) {

   389

        bip_set_port(htons((uint16_t) strtol(port, NULL, 0)));

   390

    } else {

   391

            bip_set_port(htons(0xBAC0));

   392

    }

   393

   394

    if (apdu_timeout != NULL) {

   395

        apdu_timeout_set((uint16_t) strtol(apdu_timeout, NULL, 0));

   396

    }

   397

   398

    if (apdu_retries != NULL) {

   399

        apdu_retries_set((uint8_t) strtol(apdu_retries, NULL, 0));

   400

    }

   401

   402

    // datalink_init is a pointer that will actually call bip_init()

   403

    // datalink_init pointer is set by the call datalink_set("BIP")

   404

    /* NOTE: current implementation of BACnet stack uses the interface

   405

     *       only to determine the server's local IP address and broacast address.

   406

     *       The local IP addr is later used to discard (broadcast) messages

   407

     *       it receives that were sent by itself.

   408

     *       The broadcast IP addr is used for broadcast messages.

   409

     *       WARNING: The socket itself is created to listen on all 

   410

     *       available interfaces (INADDR_ANY), so this setting may induce

   411

     *       the user in error as we will accept messages arriving on other

   412

     *       interfaces (if they exist)

   413

     *       (see bip_init() in ports/linux/bip-init.c)

   414

     *       (see bip_****() in src/bip.c)

   415

     */

   416

    char *tmp = (char *)malloc(strlen(interface) + 1);

   417

    if (tmp == NULL) return -1;

   418

    strncpy(tmp, interface, strlen(interface) + 1);

   419

    if (!datalink_init(tmp)) {

   420

        return -1;

   421

    }

   422

// #if (MAX_TSM_TRANSACTIONS)

   423

//     pEnv = getenv("BACNET_INVOKE_ID");

   424

//     if (pEnv) {

   425

//         tsm_invokeID_set((uint8_t) strtol(pEnv, NULL, 0));

   426

//     }

   427

// #endif

   428

    dlenv_register_as_foreign_device();

   429

   430

    // success

   431

    return 0;

   432

}

   433

   434

   435

// This mutex blocks execution of __init_%(locstr)s() until initialization is done

   436

static int init_done = 0;

   437

static pthread_mutex_t init_done_lock = PTHREAD_MUTEX_INITIALIZER;

   438

static pthread_cond_t init_done_cond = PTHREAD_COND_INITIALIZER;

   439

   440

/** Main function of server demo. **/

   441

int bn_server_run(server_node_t *server_node) {

   442

    int res = 0;

   443

    BACNET_ADDRESS src = {0};  /* address where message came from */

   444

    uint16_t pdu_len = 0;

   445

    unsigned timeout = 1000;       /* milliseconds */

   446

    time_t last_seconds = 0;

   447

    time_t current_seconds = 0;

   448

    uint32_t elapsed_seconds = 0;

   449

    uint32_t elapsed_milliseconds = 0;

   450

    uint32_t address_binding_tmr = 0;

   451

    uint32_t recipient_scan_tmr = 0;

   452

   453

    /* allow the device ID to be set */

   454

    Device_Set_Object_Instance_Number(server_node->device_id);

   455

    /* load any static address bindings in our device bindings list */

   456

    address_init();

   457

    /* load any entries in the BDT table from backup file */

   458

    bvlc_bdt_restore_local();

   459

    /* Initiliaze the bacnet server 'device' */    

   460

    Device_Init(server_node->device_name);

   461

   462

    /* Although the default values for the following properties are hardcoded into

   463

     * the respective variable definition+initialization in the C code,

   464

     * these values may be potentially changed after compilation but before 

   465

     * code startup. This is done by the web interface(1), directly loading the .so file, 

   466

     * and changing the values in the server_node_t variable.

   467

     * We must therefore honor those values when we start running the BACnet device server

   468

     * 

   469

     * (1) Web interface is implemented in runtime/BACnet_config.py

   470

     *     which works as an extension of the web server in runtime/NevowServer.py

   471

     *     which in turn is initialised/run by the Beremiz_service.py deamon

   472

     */

   473

    Device_Set_Location                    (server_node->device_location,        strlen(server_node->device_location));

   474

    Device_Set_Description                 (server_node->device_description,     strlen(server_node->device_description));

   475

    Device_Set_Application_Software_Version(server_node->device_appsoftware_ver, strlen(server_node->device_appsoftware_ver));

   476

    /* Set the password (max 31 chars) for Device Communication Control request. */

   477

    /* Default in the BACnet stack is hardcoded as "filister" */

   478

    /* (char *) cast is to remove the cast. The function is incorrectly declared/defined in the BACnet stack! */

   479

    /* BACnet stack needs to change demo/handler/h_dcc.c and include/handlers.h                               */

   480

    handler_dcc_password_set((char *)server_node->comm_control_passwd);

   481

   482

   483

    pthread_mutex_lock(&init_done_lock);

   484

    init_done = 1;

   485

    pthread_cond_signal(&init_done_cond);

   486

    pthread_mutex_unlock(&init_done_lock);

   487

   488

    /* Set callbacks and configure network interface */

   489

    res = Init_Service_Handlers();

   490

    if (res < 0) exit(1);

   491

    res = Init_Network_Interface(

   492

            server_node->network_interface, // interface    (NULL => use default (eth0))

   493

            server_node->port_number,       // Port number  (NULL => use default (0xBAC0))

   494

            NULL,              // apdu_timeout (NULL => use default)

   495

            NULL               // apdu_retries (NULL => use default)

   496

           );

   497

    if (res < 0) {

   498

        fprintf(stderr, "BACnet plugin: error initializing bacnet server node %%s!\n", server_node->location);

   499

        exit(1); // kill the server thread!

   500

    }

   501

    /* BACnet stack correcly configured. Give user some feedback! */

   502

    struct in_addr my_addr, broadcast_addr;

   503

    my_addr.       s_addr = bip_get_addr();

   504

    broadcast_addr.s_addr = bip_get_broadcast_addr();

   505

    printf("BACnet plugin:"

   506

                         " Local IP addr: %%s" 

   507

                        ", Broadcast IP addr: %%s" 

   508

                        ", Port number: 0x%%04X [%%hu]" 

   509

                        ", BACnet Device ID: %%d"

   510

                        ", Max APDU: %%d"

   511

                        ", BACnet Stack Version %%s\n",

   512

                        inet_ntoa(my_addr),

   513

                        inet_ntoa(broadcast_addr),

   514

                        ntohs(bip_get_port()), ntohs(bip_get_port()),

   515

                        Device_Object_Instance_Number(), 

   516

                        MAX_APDU,

   517

                        Device_Firmware_Revision()

   518

                        );

   519

    /* configure the timeout values */

   520

    last_seconds = time(NULL);

   521

    /* broadcast an I-Am on startup */

   522

    Send_I_Am(&Handler_Transmit_Buffer[0]);

   523

    /* loop forever */

   524

    for (;;) {

   525

        /* input */

   526

        current_seconds = time(NULL);

   527