#!/usr/bin/python
#
#  Copyright (c) 2016, The OpenThread Authors.
#  All rights reserved.
#
#  Redistribution and use in source and binary forms, with or without
#  modification, are permitted provided that the following conditions are met:
#  1. Redistributions of source code must retain the above copyright
#     notice, this list of conditions and the following disclaimer.
#  2. Redistributions in binary form must reproduce the above copyright
#     notice, this list of conditions and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#  3. Neither the name of the copyright holder nor the
#     names of its contributors may be used to endorse or promote products
#     derived from this software without specific prior written permission.
#
#  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
#  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
#  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
#  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
#  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
#  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
#  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
#  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
#  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
#  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
#  POSSIBILITY OF SUCH DAMAGE.
#

import os
import sys
import time
import ctypes

class otApi:
    def __init__(self, nodeid):
        self.verbose = int(float(os.getenv('VERBOSE', 0)))
        self.__init_dll(nodeid)

    def __del__(self):
        self.Api.otNodeFinalize(self.otNode)

    def set_mode(self, mode):
        if self.Api.otNodeSetMode(self.otNode, mode.encode('utf-8')) != 0:
            raise OSError("otNodeSetMode failed!")

    def interface_up(self):
        if self.Api.otNodeInterfaceUp(self.otNode) != 0:
            raise OSError("otNodeInterfaceUp failed!")

    def interface_down(self):
        if self.Api.otNodeInterfaceDown(self.otNode) != 0:
            raise OSError("otNodeInterfaceDown failed!")

    def thread_start(self):
        if self.Api.otNodeThreadStart(self.otNode) != 0:
            raise OSError("otNodeThreadStart failed!")

    def thread_stop(self):
        if self.Api.otNodeThreadStop(self.otNode) != 0:
            raise OSError("otNodeThreadStop failed!")
            
    def commissioner_start(self):
        if self.Api.otNodeCommissionerStart(self.otNode) != 0:
            raise OSError("otNodeCommissionerStart failed!")

    def commissioner_add_joiner(self, addr, psk):
        if self.Api.otNodeCommissionerJoinerAdd(self.otNode, addr.encode('utf-8'), psk.encode('utf-8')) != 0:
            raise OSError("otNodeCommissionerJoinerAdd failed!")

    def joiner_start(self, pskd='', provisioning_url=''):
        if self.Api.otNodeJoinerStart(self.otNode, pskd.encode('utf-8'), provisioning_url.encode('utf-8')) != 0:
            raise OSError("otNodeJoinerStart failed!")

    def clear_whitelist(self):
        if self.Api.otNodeClearWhitelist(self.otNode) != 0:
            raise OSError("otNodeClearWhitelist failed!")

    def enable_whitelist(self):
        if self.Api.otNodeEnableWhitelist(self.otNode) != 0:
            raise OSError("otNodeEnableWhitelist failed!")

    def disable_whitelist(self):
        if self.Api.otNodeDisableWhitelist(self.otNode) != 0:
            raise OSError("otNodeDisableWhitelist failed!")

    def add_whitelist(self, addr, rssi=None):
        if rssi == None:
            rssi = 0
        if self.Api.otNodeAddWhitelist(self.otNode, addr.encode('utf-8'), ctypes.c_byte(rssi)) != 0:
            raise OSError("otNodeAddWhitelist failed!")

    def remove_whitelist(self, addr):
        if self.Api.otNodeRemoveWhitelist(self.otNode, addr.encode('utf-8')) != 0:
            raise OSError("otNodeRemoveWhitelist failed!")

    def get_addr16(self):
        return self.Api.otNodeGetAddr16(self.otNode)

    def get_addr64(self):
        return self.Api.otNodeGetAddr64(self.otNode).decode('utf-8')

    def get_hashmacaddr(self):
        return self.Api.otNodeGetHashMacAddress(self.otNode).decode('utf-8')

    def get_channel(self):
        return self.Api.otNodeGetChannel(self.otNode)

    def set_channel(self, channel):
        if self.Api.otNodeSetChannel(self.otNode, ctypes.c_ubyte(channel)) != 0:
            raise OSError("otNodeSetChannel failed!")

    def get_masterkey(self):
        return self.Api.otNodeGetMasterkey(self.otNode).decode("utf-8")

    def set_masterkey(self, masterkey):
        if self.Api.otNodeSetMasterkey(self.otNode, masterkey.encode('utf-8')) != 0:
            raise OSError("otNodeSetMasterkey failed!")

    def get_key_sequence_counter(self):
        return self.Api.otNodeGetKeySequenceCounter(self.otNode)

    def set_key_sequence_counter(self, key_sequence_counter):
        if self.Api.otNodeSetKeySequenceCounter(self.otNode, ctypes.c_uint(key_sequence_counter)) != 0:
            raise OSError("otNodeSetKeySequenceCounter failed!")

    def set_key_switch_guardtime(self, key_switch_guardtime):
        if self.Api.otNodeSetKeySwitchGuardTime(self.otNode, ctypes.c_uint(key_switch_guardtime)) != 0:
            raise OSError("otNodeSetKeySwitchGuardTime failed!")

    def set_network_id_timeout(self, network_id_timeout):
        if self.Api.otNodeSetNetworkIdTimeout(self.otNode, ctypes.c_ubyte(network_id_timeout)) != 0:
            raise OSError("otNodeSetNetworkIdTimeout failed!")

    def get_network_name(self):
        return self.Api.otNodeGetNetworkName(self.otNode).decode("utf-8")

    def set_network_name(self, network_name):
        if self.Api.otNodeSetNetworkName(self.otNode, network_name.encode('utf-8')) != 0:
            raise OSError("otNodeSetNetworkName failed!")

    def get_panid(self):
        return int(self.Api.otNodeGetPanId(self.otNode))

    def set_panid(self, panid):
        if self.Api.otNodeSetPanId(self.otNode, ctypes.c_ushort(panid)) != 0:
            raise OSError("otNodeSetPanId failed!")

    def get_partition_id(self):
        return int(self.Api.otNodeGetPartitionId(self.otNode))

    def set_partition_id(self, partition_id):
        if self.Api.otNodeSetPartitionId(self.otNode, ctypes.c_uint(partition_id)) != 0:
            raise OSError("otNodeSetPartitionId failed!")

    def set_router_upgrade_threshold(self, threshold):
        if self.Api.otNodeSetRouterUpgradeThreshold(self.otNode, ctypes.c_ubyte(threshold)) != 0:
            raise OSError("otNodeSetRouterUpgradeThreshold failed!")

    def set_router_downgrade_threshold(self, threshold):
        if self.Api.otNodeSetRouterDowngradeThreshold(self.otNode, ctypes.c_ubyte(threshold)) != 0:
            raise OSError("otNodeSetRouterDowngradeThreshold failed!")

    def release_router_id(self, router_id):
        if self.Api.otNodeReleaseRouterId(self.otNode, ctypes.c_ubyte(router_id)) != 0:
            raise OSError("otNodeReleaseRouterId failed!")

    def get_state(self):
        return self.Api.otNodeGetState(self.otNode).decode('utf-8')

    def set_state(self, state):
        if self.Api.otNodeSetState(self.otNode, state.encode('utf-8')) != 0:
            raise OSError("otNodeSetState failed!")

    def get_timeout(self):
        return int(self.Api.otNodeGetTimeout(self.otNode))

    def set_timeout(self, timeout):
        if self.Api.otNodeSetTimeout(self.otNode, ctypes.c_uint(timeout)) != 0:
            raise OSError("otNodeSetTimeout failed!")

    def set_max_children(self, number):
        if self.Api.otNodeSetMaxChildren(self.otNode, ctypes.c_ubyte(number)) != 0:
            raise OSError("otNodeSetMaxChildren failed!")

    def get_weight(self):
        return int(self.Api.otNodeGetWeight(self.otNode))

    def set_weight(self, weight):
        if self.Api.otNodeSetWeight(self.otNode, ctypes.c_ubyte(weight)) != 0:
            raise OSError("otNodeSetWeight failed!")

    def add_ipaddr(self, ipaddr):
        if self.Api.otNodeAddIpAddr(self.otNode, ipaddr.encode('utf-8')) != 0:
            raise OSError("otNodeAddIpAddr failed!")

    def get_addrs(self):
        return self.Api.otNodeGetAddrs(self.otNode).decode("utf-8").split("\n")

    def get_context_reuse_delay(self):
        return int(self.Api.otNodeGetContextReuseDelay(self.otNode))

    def set_context_reuse_delay(self, delay):
        if self.Api.otNodeSetContextReuseDelay(self.otNode, ctypes.c_uint(delay)) != 0:
            raise OSError("otNodeSetContextReuseDelay failed!")

    def add_prefix(self, prefix, flags, prf = 'med'):
        if self.Api.otNodeAddPrefix(self.otNode, prefix.encode('utf-8'), flags.encode('utf-8'), prf.encode('utf-8')) != 0:
            raise OSError("otNodeAddPrefix failed!")

    def remove_prefix(self, prefix):
        if self.Api.otNodeRemovePrefix(self.otNode, prefix.encode('utf-8')) != 0:
            raise OSError("otNodeRemovePrefix failed!")

    def add_route(self, prefix, prf = 'med'):
        if self.Api.otNodeAddRoute(self.otNode, prefix.encode('utf-8'), prf.encode('utf-8')) != 0:
            raise OSError("otNodeAddRoute failed!")

    def remove_route(self, prefix):
        if self.Api.otNodeRemoveRoute(self.otNode, prefix.encode('utf-8')) != 0:
            raise OSError("otNodeRemovePrefix failed!")

    def register_netdata(self):
        if self.Api.otNodeRegisterNetdata(self.otNode) != 0:
            raise OSError("otNodeRegisterNetdata failed!")

    def energy_scan(self, mask, count, period, scan_duration, ipaddr):
        if self.Api.otNodeEnergyScan(self.otNode, ctypes.c_uint(mask), ctypes.c_ubyte(count), ctypes.c_ushort(period), ctypes.c_ushort(scan_duration), ipaddr.encode('utf-8')) != 0:
            raise OSError("otNodeEnergyScan failed!")

    def panid_query(self, panid, mask, ipaddr):
        if self.Api.otNodePanIdQuery(self.otNode, ctypes.c_ushort(panid), ctypes.c_uint(mask), ipaddr.encode('utf-8')) != 0:
            raise OSError("otNodePanIdQuery failed!")

    def scan(self):
        return self.Api.otNodeScan(self.otNode).decode("utf-8").split("\n")

    def ping(self, ipaddr, num_responses=1, size=None):
        if size == None:
            size = 100
        numberOfResponders = self.Api.otNodePing(self.otNode, ipaddr.encode('utf-8'), ctypes.c_ushort(size), ctypes.c_uint(num_responses))
        return numberOfResponders >= num_responses

    def set_router_selection_jitter(self, jitter):
        if self.Api.otNodeSetRouterSelectionJitter(self.otNode, ctypes.c_ubyte(jitter)) != 0:
            raise OSError("otNodeSetRouterSelectionJitter failed!")

    def set_active_dataset(self, timestamp, panid=None, channel=None, channel_mask=None, master_key=None):
        if panid == None:
            panid = 0
        if channel == None:
            channel = 0
        if channel_mask == None:
            channel_mask = 0
        if master_key == None:
            master_key = ""
        if self.Api.otNodeSetActiveDataset(
                self.otNode,
                ctypes.c_ulonglong(timestamp),
                ctypes.c_ushort(panid),
                ctypes.c_ushort(channel),
                ctypes.c_uint(channel_mask),
                master_key.encode('utf-8')
            ) != 0:
            raise OSError("otNodeSetActiveDataset failed!")

    def set_pending_dataset(self, pendingtimestamp, activetimestamp, panid=None, channel=None):
        if pendingtimestamp == None:
            pendingtimestamp = 0
        if activetimestamp == None:
            activetimestamp = 0
        if panid == None:
            panid = 0
        if channel == None:
            channel = 0
        if self.Api.otNodeSetPendingDataset(
                self.otNode,
                ctypes.c_ulonglong(activetimestamp),
                ctypes.c_ulonglong(pendingtimestamp),
                ctypes.c_ushort(panid),
                ctypes.c_ushort(channel)
            ) != 0:
            raise OSError("otNodeSetPendingDataset failed!")

    def announce_begin(self, mask, count, period, ipaddr):
        if self.Api.otNodeCommissionerAnnounceBegin(self.otNode, ctypes.c_uint(mask), ctypes.c_ubyte(count), ctypes.c_ushort(period), ipaddr.encode('utf-8')) != 0:
            raise OSError("otNodeCommissionerAnnounceBegin failed!")

    def send_mgmt_active_set(self, active_timestamp=None, channel=None, channel_mask=None, extended_panid=None,
                             panid=None, master_key=None, mesh_local=None, network_name=None, binary=None):
        if active_timestamp == None:
            active_timestamp = 0
        if panid == None:
            panid = 0
        if channel == None:
            channel = 0
        if channel_mask == None:
            channel_mask = 0
        if extended_panid == None:
            extended_panid = ""
        if master_key == None:
            master_key = ""
        if mesh_local == None:
            mesh_local = ""
        if network_name == None:
            network_name = ""
        if binary == None:
            binary = ""
        if self.Api.otNodeSendActiveSet(
                self.otNode, 
                ctypes.c_ulonglong(active_timestamp), 
                ctypes.c_ushort(panid), 
                ctypes.c_ushort(channel), 
                ctypes.c_uint(channel_mask), 
                extended_panid.encode('utf-8'), 
                master_key.encode('utf-8'), 
                mesh_local.encode('utf-8'), 
                network_name.encode('utf-8'), 
                binary.encode('utf-8')
            ) != 0:
            raise OSError("otNodeSendActiveSet failed!")

    def send_mgmt_pending_set(self, pending_timestamp=None, active_timestamp=None, delay_timer=None, channel=None,
                              panid=None, master_key=None, mesh_local=None, network_name=None):
        if pending_timestamp == None:
            pending_timestamp = 0
        if active_timestamp == None:
            active_timestamp = 0
        if delay_timer == None:
            delay_timer = 0
        if panid == None:
            panid = 0
        if channel == None:
            channel = 0
        if master_key == None:
            master_key = ""
        if mesh_local == None:
            mesh_local = ""
        if network_name == None:
            network_name = ""
        if self.Api.otNodeSendPendingSet(
                self.otNode,
                ctypes.c_ulonglong(active_timestamp),
                ctypes.c_ulonglong(pending_timestamp),
                ctypes.c_uint(delay_timer),
                ctypes.c_ushort(panid),
                ctypes.c_ushort(channel),
                master_key.encode('utf-8'),
                mesh_local.encode('utf-8'),
                network_name.encode('utf-8')
            ) != 0:
            raise OSError("otNodeSendPendingSet failed!")

    def log(self, message):
        self.Api.otNodeLog(message)

    def __init_dll(self, nodeid):
        """ Initialize the API from a Windows DLL. """

        # Load the DLL
        self.Api = ctypes.WinDLL("otnodeapi.dll")
        if self.Api == None:
            raise OSError("Failed to load otnodeapi.dll!")
        
        # Define the functions
        self.Api.otNodeLog.argtypes = [ctypes.c_char_p]

        self.Api.otNodeInit.argtypes = [ctypes.c_uint]
        self.Api.otNodeInit.restype = ctypes.c_void_p

        self.Api.otNodeFinalize.argtypes = [ctypes.c_void_p]

        self.Api.otNodeSetMode.argtypes = [ctypes.c_void_p, 
                                           ctypes.c_char_p]

        self.Api.otNodeInterfaceUp.argtypes = [ctypes.c_void_p]

        self.Api.otNodeInterfaceDown.argtypes = [ctypes.c_void_p]

        self.Api.otNodeThreadStart.argtypes = [ctypes.c_void_p]

        self.Api.otNodeThreadStop.argtypes = [ctypes.c_void_p]

        self.Api.otNodeCommissionerStart.argtypes = [ctypes.c_void_p]

        self.Api.otNodeCommissionerJoinerAdd.argtypes = [ctypes.c_void_p, 
                                                         ctypes.c_char_p,
                                                         ctypes.c_char_p]

        self.Api.otNodeCommissionerStop.argtypes = [ctypes.c_void_p]

        self.Api.otNodeJoinerStart.argtypes = [ctypes.c_void_p, 
                                               ctypes.c_char_p,
                                               ctypes.c_char_p]

        self.Api.otNodeJoinerStop.argtypes = [ctypes.c_void_p]

        self.Api.otNodeClearWhitelist.argtypes = [ctypes.c_void_p]

        self.Api.otNodeEnableWhitelist.argtypes = [ctypes.c_void_p]

        self.Api.otNodeDisableWhitelist.argtypes = [ctypes.c_void_p]

        self.Api.otNodeAddWhitelist.argtypes = [ctypes.c_void_p, 
                                                ctypes.c_char_p, 
                                                ctypes.c_byte]

        self.Api.otNodeRemoveWhitelist.argtypes = [ctypes.c_void_p, 
                                                   ctypes.c_char_p]
        
        self.Api.otNodeGetAddr16.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetAddr16.restype = ctypes.c_ushort
        
        self.Api.otNodeGetAddr64.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetAddr64.restype = ctypes.c_char_p
        
        self.Api.otNodeGetHashMacAddress.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetHashMacAddress.restype = ctypes.c_char_p

        self.Api.otNodeSetChannel.argtypes = [ctypes.c_void_p, 
                                              ctypes.c_ubyte]
        
        self.Api.otNodeGetChannel.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetChannel.restype = ctypes.c_ubyte

        self.Api.otNodeSetMasterkey.argtypes = [ctypes.c_void_p, 
                                                ctypes.c_char_p]
        
        self.Api.otNodeGetMasterkey.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetMasterkey.restype = ctypes.c_char_p
        
        self.Api.otNodeGetKeySequenceCounter.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetKeySequenceCounter.restype = ctypes.c_uint

        self.Api.otNodeSetKeySequenceCounter.argtypes = [ctypes.c_void_p, 
                                                         ctypes.c_uint]

        self.Api.otNodeSetKeySwitchGuardTime.argtypes = [ctypes.c_void_p, 
                                                         ctypes.c_uint]

        self.Api.otNodeSetNetworkIdTimeout.argtypes = [ctypes.c_void_p, 
                                                       ctypes.c_ubyte]
        
        self.Api.otNodeGetNetworkName.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetNetworkName.restype = ctypes.c_char_p

        self.Api.otNodeSetNetworkName.argtypes = [ctypes.c_void_p, 
                                                  ctypes.c_char_p]
        
        self.Api.otNodeGetPanId.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetPanId.restype = ctypes.c_ushort

        self.Api.otNodeSetPanId.argtypes = [ctypes.c_void_p, 
                                            ctypes.c_ushort]
        
        self.Api.otNodeGetPartitionId.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetPartitionId.restype = ctypes.c_uint

        self.Api.otNodeSetPartitionId.argtypes = [ctypes.c_void_p, 
                                                  ctypes.c_uint]

        self.Api.otNodeSetRouterUpgradeThreshold.argtypes = [ctypes.c_void_p, 
                                                             ctypes.c_ubyte]

        self.Api.otNodeSetRouterDowngradeThreshold.argtypes = [ctypes.c_void_p, 
                                                               ctypes.c_ubyte]

        self.Api.otNodeReleaseRouterId.argtypes = [ctypes.c_void_p, 
                                                   ctypes.c_ubyte]
        
        self.Api.otNodeGetState.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetState.restype = ctypes.c_char_p

        self.Api.otNodeSetState.argtypes = [ctypes.c_void_p, 
                                            ctypes.c_char_p]
        
        self.Api.otNodeGetTimeout.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetTimeout.restype = ctypes.c_uint

        self.Api.otNodeSetTimeout.argtypes = [ctypes.c_void_p, 
                                            ctypes.c_uint]
        
        self.Api.otNodeGetWeight.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetWeight.restype = ctypes.c_ubyte

        self.Api.otNodeSetWeight.argtypes = [ctypes.c_void_p, 
                                             ctypes.c_ubyte]

        self.Api.otNodeAddIpAddr.argtypes = [ctypes.c_void_p, 
                                             ctypes.c_char_p]
        
        self.Api.otNodeGetAddrs.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetAddrs.restype = ctypes.c_char_p
        
        self.Api.otNodeGetContextReuseDelay.argtypes = [ctypes.c_void_p]
        self.Api.otNodeGetContextReuseDelay.restype = ctypes.c_uint

        self.Api.otNodeSetContextReuseDelay.argtypes = [ctypes.c_void_p, 
                                                        ctypes.c_uint]

        self.Api.otNodeAddPrefix.argtypes = [ctypes.c_void_p, 
                                             ctypes.c_char_p, 
                                             ctypes.c_char_p, 
                                             ctypes.c_char_p]

        self.Api.otNodeRemovePrefix.argtypes = [ctypes.c_void_p, 
                                                ctypes.c_char_p]

        self.Api.otNodeAddRoute.argtypes = [ctypes.c_void_p, 
                                            ctypes.c_char_p, 
                                            ctypes.c_char_p]

        self.Api.otNodeRemoveRoute.argtypes = [ctypes.c_void_p, 
                                               ctypes.c_char_p]

        self.Api.otNodeRegisterNetdata.argtypes = [ctypes.c_void_p]

        self.Api.otNodeEnergyScan.argtypes = [ctypes.c_void_p, 
                                              ctypes.c_uint, 
                                              ctypes.c_ubyte, 
                                              ctypes.c_ushort, 
                                              ctypes.c_ushort, 
                                              ctypes.c_char_p]

        self.Api.otNodePanIdQuery.argtypes = [ctypes.c_void_p, 
                                              ctypes.c_ushort, 
                                              ctypes.c_uint, 
                                              ctypes.c_char_p]

        self.Api.otNodeScan.argtypes = [ctypes.c_void_p]
        self.Api.otNodeScan.restype = ctypes.c_char_p

        self.Api.otNodePing.argtypes = [ctypes.c_void_p, 
                                        ctypes.c_char_p,
                                        ctypes.c_ushort,
                                        ctypes.c_uint]
        self.Api.otNodePing.restype = ctypes.c_uint

        self.Api.otNodeSetRouterSelectionJitter.argtypes = [ctypes.c_void_p, 
                                                            ctypes.c_ubyte]

        self.Api.otNodeCommissionerAnnounceBegin.argtypes = [ctypes.c_void_p,
                                                             ctypes.c_uint,
                                                             ctypes.c_ubyte,
                                                             ctypes.c_ushort,
                                                             ctypes.c_char_p]

        self.Api.otNodeSetActiveDataset.argtypes = [ctypes.c_void_p,
                                                    ctypes.c_ulonglong,
                                                    ctypes.c_ushort,
                                                    ctypes.c_ushort,
                                                    ctypes.c_uint,
                                                    ctypes.c_char_p]

        self.Api.otNodeSetPendingDataset.argtypes = [ctypes.c_void_p,
                                                     ctypes.c_ulonglong,
                                                     ctypes.c_ulonglong,
                                                     ctypes.c_ushort,
                                                     ctypes.c_ushort]

        self.Api.otNodeSendPendingSet.argtypes = [ctypes.c_void_p,
                                                  ctypes.c_ulonglong,
                                                  ctypes.c_ulonglong,
                                                  ctypes.c_uint,
                                                  ctypes.c_ushort,
                                                  ctypes.c_ushort,
                                                  ctypes.c_char_p,
                                                  ctypes.c_char_p,
                                                  ctypes.c_char_p]

        self.Api.otNodeSendActiveSet.argtypes = [ctypes.c_void_p,
                                                 ctypes.c_ulonglong,
                                                 ctypes.c_ushort,
                                                 ctypes.c_ushort,
                                                 ctypes.c_uint,
                                                 ctypes.c_char_p,
                                                 ctypes.c_char_p,
                                                 ctypes.c_char_p,
                                                 ctypes.c_char_p,
                                                 ctypes.c_char_p]

        self.Api.otNodeSetMaxChildren.argtypes = [ctypes.c_void_p, 
                                                  ctypes.c_ubyte]
        
        # Initialize a new node
        self.otNode = self.Api.otNodeInit(ctypes.c_uint(nodeid))
        if self.otNode == None:
            raise OSError("otNodeInit failed!")
