motify compile link error

motify compile link error

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/Controller/Controller.h

@@ -0,0 +1,37 @@
+//
+//  Controller.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/18.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "AsyncUdpSocket.h"
+#import "AsyncSocket.h"
+#import "Defines.h"
+
+@interface Controller : NSObject <AsyncUdpSocketDelegate>
+{
+@private
+    unsigned int m_mode;
+    unsigned int m_result;
+    NSString     *m_dev_pin;
+}
+
+@property (nonatomic, strong) AsyncUdpSocket *control_sock;
+@property (nonatomic, strong) NSData         *control_data;
+@property (nonatomic, strong) NSData         *ack_data;
+
+-(id)init;
+-(void)rtk_sc_close_sock;
+-(void)rtk_sc_reopen_sock;
+-(int) rtk_sc_get_mode;
+-(int) rtk_sc_get_control_result;
+
+-(void)rtk_sc_gen_control_data: (unsigned int)type pin: (NSString *)pin name: (NSString *)name;
+-(int) rtk_sc_send_control_data: (unsigned int)ip;
+
+- (unsigned int)rtk_sc_convert_host_to_ip: (NSString *)host;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/Controller/Controller.m

@@ -0,0 +1,382 @@
+//
+//  Controller.m
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/18.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import "Controller.h"
+#import <Foundation/Foundation.h>
+#import <CommonCrypto/CommonDigest.h>
+#import <CommonCrypto/CommonCryptor.h>
+#import <CommonCrypto/CommonHMAC.h>
+
+#define SC_CONTROL_DEF_PIN             @"57289961"
+
+@implementation Controller
+@synthesize control_sock, control_data, ack_data;
+
+-(id)init
+{
+    NSError *err;
+    control_sock = [[AsyncUdpSocket alloc]initWithDelegate:self];
+    [control_sock bindToPort:(LOCAL_PORT_NUM) error:&err];
+    m_mode = MODE_INIT;
+    m_result = RTK_FAILED;
+    
+    return [super init];
+}
+
+-(void)dealloc
+{
+#ifdef ARC
+    [control_data release];
+    [control_sock dealloc];
+    [ack_data release];
+    [m_dev_pin release];
+
+    [super dealloc];
+#endif
+}
+
+-(void)rtk_sc_close_sock
+{
+    if (![control_sock isClosed]) {
+        NSLog(@"m_controller close");
+        [control_sock close];
+    }
+}
+-(void)rtk_sc_reopen_sock
+{
+    NSError *err;
+    if ([control_sock isClosed]) {
+        NSLog(@"m_controller reopen");
+        control_sock = [[AsyncUdpSocket alloc]initWithDelegate:self];
+        [control_sock bindToPort:(LOCAL_PORT_NUM) error:&err];
+    }
+}
+
+-(int)rtk_sc_get_mode
+{
+    return m_mode;
+}
+
+-(int) rtk_sc_get_control_result
+{
+    return (m_result==1)?RTK_SUCCEED:RTK_FAILED;
+}
+
+- (unsigned int)rtk_sc_convert_host_to_ip: (NSString *)host
+{
+    unsigned char ip[4] = {0x0};
+    int idx = 3;
+    NSArray *arr = [host componentsSeparatedByString:@"."];
+    for(NSString *s in arr)
+    {
+        int a = [s intValue];
+        ip[idx] = a & 0xFF;
+        idx--;
+    }
+    unsigned int ret;
+    memcpy(&ret, ip, 4);
+    NSLog(@"ret = %x", ret);
+    return ret;
+}
+
+-(void)rtk_sc_gen_control_data: (unsigned int)type pin: (NSString *)pin name: (NSString *)name
+{
+    if (type==RTK_SC_CONTROL_DELETE) {
+        [self gen_control_data:REQ_DEL_PROFILE length:(CONTROL_DATA_LEN-1-1-2) psw:SC_CONTROL_DEF_PIN dev_pin:pin name:name];
+        m_mode = MODE_CONTROL;
+    }else if(type==RTK_SC_CONTROL_RENAME){
+        [self gen_control_data:REQ_RENAME_DEV length:(unsigned int)(CONTROL_DATA_LEN-1-1-2+[name length]) psw:SC_CONTROL_DEF_PIN dev_pin:pin name:name];
+        m_mode = MODE_CONTROL;
+    }else{
+        NSLog(@"ERROR: UNKNOWN CONTROL TYPE!!");
+    }
+}
+
+-(int)rtk_sc_send_control_data: (unsigned int)ip
+{
+    if (m_mode != MODE_CONTROL) {
+        return RTK_FAILED;
+    }
+    
+    int ret = RTK_FAILED;
+    if(control_sock == nil){
+        NSLog(@"udpSocket doesn't exist!!!");
+        return -1;
+    }
+    
+    NSString *host = [[NSString alloc] initWithString:[NSString stringWithFormat:@"%d.%d.%d.%d", (ip>>24)&0xFF, (ip>>16)&0xFF, (ip>>8)&0xFF, ip&0xFF]];
+    
+    // send data(unicast)
+    [control_sock receiveWithTimeout:-1 tag:0];
+    BOOL result = [control_sock sendData:control_data toHost:host port:UNICAST_PORT_NUM withTimeout:-1 tag:0];
+    // deal with send result
+    if(!result)
+        ret=RTK_FAILED;
+    else
+        ret=RTK_SUCCEED;
+    
+    NSLog(@"Finish send control data");
+#ifdef ARC
+    [host release];
+#endif
+    
+    return ret;
+}
+
+/* private funcs */
+- (void) gen_control_data:(unsigned char)flag length:(unsigned int)length psw:(NSString *)psw dev_pin:(NSString *)dev_pin name:(NSString *)name
+{
+    NSLog(@"Control: m_mode=%d", m_mode);
+    unsigned char buffer[CONTROL_DATA_LEN*2]={0x0};
+    unsigned int len = 0;
+    unsigned char m_security_level = SC_USE_ENCRYPTION;
+    m_dev_pin = [[NSString alloc] initWithString:dev_pin];
+#ifdef ARC
+    [m_dev_pin retain];
+#endif
+    
+    /* flag */
+    memcpy(buffer+len, &flag, 1);
+    len+=1;
+    NSLog(@"Control: flag = %02x", flag);
+    
+    /* security level */
+    memcpy(buffer+len, &m_security_level, 1);
+    len += 1;
+    NSLog(@"Control: security level = %02x", m_security_level);
+    
+    /* length */
+    const char *name_p = [name UTF8String];
+    NSLog(@"Control: name=%s", name_p);
+    unsigned char data_len[2]={0};
+    if (flag == REQ_RENAME_DEV)
+        data_len[1]= (unsigned char)(length+strlen(name_p));
+    else
+        data_len[1]= (unsigned char)(length);
+    memcpy(buffer+len, data_len, 2);
+    len+=2;
+    NSLog(@"Control: length = %02x%02x", data_len[0], data_len[1]);
+    
+    /* Nonce: a random value */
+    unsigned char nonce[64] = {0x0};
+    int nonce_idx = 0;
+    for (nonce_idx=0; nonce_idx<64; nonce_idx++) {
+        nonce[nonce_idx] = 0 + rand()%255;
+        //NSLog(@"[%d]: %02x", nonce_idx, nonce[nonce_idx]);
+    }
+    memcpy(buffer+len, nonce, 64);
+    len += 64;
+    
+    NSLog(@"Control: default pin = %@", psw);
+    NSLog(@"Control: dev pin = %@", dev_pin);
+    const unsigned char *psw_char = (const unsigned char *)[psw cStringUsingEncoding:NSASCIIStringEncoding];
+    unsigned int psw_len = (unsigned int)strlen((const char *)psw_char);
+    const unsigned char *pin_char = (const unsigned char*)[dev_pin cStringUsingEncoding:NSASCIIStringEncoding];
+    unsigned int dev_pin_len = (unsigned int)strlen((const char *)pin_char);
+    
+    unsigned char md5_buffer[64+64]={0x0};
+    unsigned char md5_result[16] = {0x0};
+    /* Digest1: md5 buffer is nonce+default_pin */
+    //NSLog(@"Control: default_pin_char(%d) = %s", psw_len, psw_char);
+    memcpy(md5_buffer, nonce, 64);
+    memcpy(md5_buffer+64, psw_char, psw_len);
+    CC_MD5(md5_buffer, 64+psw_len, md5_result);
+    memcpy(buffer+len, md5_result, 16);
+    len += 16;
+    
+    /* Digest2: md5 buffer is nonce+dev_pin */
+    //NSLog(@"Control: dev pin_char(%d) = %s", dev_pin_len, pin_char);
+    memset(md5_buffer, 0x0, 64+64);
+    memset(md5_result, 0x0, 16);
+    memcpy(md5_buffer, nonce, 64);
+    memcpy(md5_buffer+64, pin_char, dev_pin_len);
+    CC_MD5(md5_buffer, 64+dev_pin_len, md5_result);
+    memcpy(buffer+len, md5_result, 16);
+    len += 16;
+    
+    control_data = [NSData dataWithBytes:(const void*)buffer length:CONTROL_DATA_LEN];
+#ifdef ARC
+    [control_data retain];
+#endif
+    
+    /* Add name if necessary */
+    if (flag == REQ_RENAME_DEV) {
+        NSMutableData *pkt = [NSMutableData dataWithData:control_data];
+        NSData *b = [name dataUsingEncoding:NSUTF8StringEncoding];
+        NSLog(@"dev name is(%d) %s", (unsigned int)[b length], (unsigned char *)[b bytes]);
+        [pkt appendData:b];
+        control_data = [NSData dataWithData:pkt];
+    }
+}
+
+-(void)gen_control_ack_data:(unsigned char)control_type length:(unsigned int)length
+{
+    unsigned char buffer[ACK_TO_CONTROL_DATA_LEN]={0x0};
+    unsigned int len = 0;
+    unsigned char m_security_level = SC_USE_ENCRYPTION;
+    NSString *psw = SC_CONTROL_DEF_PIN;
+    NSString *dev_pin = m_dev_pin;
+    
+    /* flag */
+    unsigned char flag = REQ_ACK;
+    memcpy(buffer+len, &flag, 1);
+    len+=1;
+    //NSLog(@"Control ACK: flag = %02x", flag);
+    
+    /* length */
+    unsigned char data_len[2]={0x0, (unsigned char)length};
+    memcpy(buffer+len, data_len, 2);
+    len+=2;
+    //NSLog(@"Control ACK: length = %02x%02x", data_len[0], data_len[1]);
+    
+    /* security level */
+    memcpy(buffer+len, &m_security_level, 1);
+    len += 1;
+    //NSLog(@"Control ACK: security level = %02x", m_security_level);
+    
+    /* Nonce: a random value */
+    unsigned char nonce[64] = {0x0};
+    int nonce_idx = 0;
+    for (nonce_idx=0; nonce_idx<64; nonce_idx++) {
+        nonce[nonce_idx] = 0 + rand()%255;
+        //NSLog(@"[%d]: %02x", nonce_idx, nonce[nonce_idx]);
+    }
+    memcpy(buffer+len, nonce, 64);
+    len += 64;
+    
+    //NSLog(@"Control ACK: default pin = %@", psw);
+    //NSLog(@"Control ACK: dev pin = %@", dev_pin);
+    const unsigned char *psw_char = (const unsigned char *)[psw cStringUsingEncoding:NSASCIIStringEncoding];
+    unsigned int psw_len = (unsigned int)strlen((const char *)psw_char);
+    const unsigned char *pin_char = (const unsigned char*)[dev_pin cStringUsingEncoding:NSASCIIStringEncoding];
+    unsigned int dev_pin_len = (unsigned int)strlen((const char *)pin_char);
+    
+    unsigned char md5_buffer[64+64]={0x0};
+    unsigned char md5_result[16] = {0x0};
+    /* Digest1: md5 buffer is nonce+default_pin */
+    //NSLog(@"Control ACK: default_pin_char(%d) = %s", psw_len, psw_char);
+    memcpy(md5_buffer, nonce, 64);
+    memcpy(md5_buffer+64, psw_char, psw_len);
+    CC_MD5(md5_buffer, 64+psw_len, md5_result);
+    memcpy(buffer+len, md5_result, 16);
+    len += 16;
+    
+    /* Digest2: md5 buffer is nonce+dev_pin */
+    //NSLog(@"Control ACK: dev pin_char(%d) = %s", dev_pin_len, pin_char);
+    memset(md5_buffer, 0x0, 64+64);
+    memset(md5_result, 0x0, 16);
+    memcpy(md5_buffer, nonce, 64);
+    memcpy(md5_buffer+64, pin_char, dev_pin_len);
+    CC_MD5(md5_buffer, 64+dev_pin_len, md5_result);
+    memcpy(buffer+len, md5_result, 16);
+    len += 16;
+    
+    /* control type */
+    //NSLog(@"Control ACK: control type is %02x", control_type);
+    unsigned char last_byte;
+    switch (control_type) {
+        case 0x22:
+            last_byte = BIT(0);
+            break;
+        case 0x23:
+            last_byte = BIT(1);
+            break;
+        case 0x24:
+            last_byte = BIT(1)|BIT(0);
+            break;
+        default:
+            last_byte = BIT(0)|BIT(1)|BIT(2)|BIT(3)|BIT(4);
+            break;
+    }
+    //NSLog(@"Control ACK: last byte is %02x", last_byte);
+    memcpy(buffer+len, &last_byte, 1);
+    len += 1;
+    
+    ack_data = [NSData dataWithBytes:(const void*)buffer length:ACK_TO_CONTROL_DATA_LEN];
+#ifdef ARC
+    [ack_data retain];
+#endif
+}
+
+-(int)send_control_ack_data: (unsigned int)ip
+{
+    int ret = RTK_FAILED;
+    if(control_sock == nil){
+        NSLog(@"udpSocket doesn't exist!!!");
+        return -1;
+    }
+    
+    NSString *host = [[NSString alloc] initWithString:[NSString stringWithFormat:@"%d.%d.%d.%d", (ip>>24)&0xFF, (ip>>16)&0xFF, (ip>>8)&0xFF, ip&0xFF]];
+    
+    // send data(unicast)
+    [control_sock receiveWithTimeout:-1 tag:0];
+    BOOL result = [control_sock sendData:ack_data toHost:host port:UNICAST_PORT_NUM withTimeout:-1 tag:0];
+    // deal with send result
+    if(!result)
+        ret=RTK_FAILED;
+    else
+        ret=RTK_SUCCEED;
+    
+    NSLog(@"Finish send control ack data");
+#ifdef ARC
+    [host release];
+#endif
+    
+    return ret;
+}
+
+/* AsyncUDPSocket delegate */
+- (BOOL)onUdpSocket:(AsyncSocket *)sock didReceiveData:(NSData *)data withTag:(long)tag fromHost:(NSString *)host port:(UInt16)port
+{
+    if (data==nil||host==nil) {
+        return NO;
+    }
+    NSLog(@"======================Control: received data from %@:%d==============================", host, port);
+    
+    /* step 1: get the received data */
+    unsigned char flag;
+    unsigned char *data_p = (unsigned char*)[data bytes];
+    if (data_p == nil) {
+        NSLog(@"data received is nil!!!");
+        return false;
+    }
+    unsigned int data_length = (unsigned int)(data_p[2]);
+    if (data_length<RESP_MIN_LEN) {
+        NSLog(@"illegel received data with length %d", data_length);
+        return false;
+    }
+    flag = data_p[0];
+    
+#if 0
+    // for debug
+    NSLog(@"control received data is %ld bytes: ", (unsigned long)[data length]);
+    
+    int recv_idx = 0;
+    for (recv_idx=0; recv_idx<(data_length+3); recv_idx++) {
+        NSLog(@"[%d]: %02x", recv_idx, data_p[recv_idx]);
+    }
+#endif
+    
+    /* step 2: parse the data */
+    if (flag==RSP_DEL_PROFILE || flag==RSP_RENAME_DEV) {
+        unsigned int ack_ip = [self rtk_sc_convert_host_to_ip:host];
+        unsigned char ack_result = data_p[3];
+        //NSLog(@"ack_ip=%x", ack_ip);
+        //NSLog(@"dev pin=%@", m_dev_pin);
+        //NSLog(@"ack_result=%d", ack_result);
+        
+        m_result = ack_result;
+        [self gen_control_ack_data:flag length:CONTROL_ACK_ACK_LEN];
+        [self send_control_ack_data:ack_ip];
+        m_mode = MODE_INIT;
+        NSLog(@"ack sent");
+    }
+    
+    return YES;
+}
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/Discover/Scanner.h

@@ -0,0 +1,32 @@
+//
+//  Scanner.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/14.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import "AsyncSocket.h"
+#import "AsyncUdpSocket.h"
+#import "Defines.h"
+#define SCANNER_DBG 0
+
+@interface Scanner : NSObject <AsyncUdpSocketDelegate>
+{
+@private
+    NSMutableArray *m_devlist;                              // scanned device list
+}
+
+@property (strong, nonatomic) AsyncUdpSocket *scan_socket; 
+@property (strong, nonatomic) NSData         *scan_data;    // scan data
+
+-(id)init;
+-(void)rtk_sc_build_scan_data: (unsigned int)security_level;
+-(int)rtk_sc_start_scan;
+-(NSMutableArray *)rtk_sc_get_scan_list;
+
+-(void)rtk_sc_close_sock;
+-(void)rtk_sc_reopen_sock;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/Discover/Scanner.m

@@ -0,0 +1,289 @@
+//
+//  Scanner.m
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/14.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import "Scanner.h"
+#import <Foundation/Foundation.h>
+#import <CommonCrypto/CommonDigest.h>
+#import <CommonCrypto/CommonCryptor.h>
+#import <CommonCrypto/CommonHMAC.h>
+
+#define SC_SCAN_PIN             @"57289961"
+
+@implementation Scanner
+@synthesize scan_socket;
+@synthesize scan_data;
+
+-(id)init
+{
+    NSError *err;
+    
+    /* init udp socket */
+    //NSLog(@"Scanner init");
+    scan_socket = [[AsyncUdpSocket alloc]initWithDelegate:self];
+    [scan_socket bindToPort:(LOCAL_PORT_NUM) error:&err]; //this port is udpSocket's port instead of dport
+    [scan_socket enableBroadcast:true error:&err];
+    [scan_socket receiveWithTimeout:-1 tag:0];
+    
+    /* init scan result list */
+    m_devlist = [[NSMutableArray alloc] initWithObjects:nil];
+    
+    return [super init];
+}
+
+-(void)dealloc
+{
+    [scan_socket close];
+#ifdef ARC
+    [scan_socket dealloc];
+#endif
+    scan_socket = nil;
+#ifdef ARC
+    [m_devlist dealloc];
+    [scan_data release];
+#endif
+    NSLog(@"scan socket close and dealloc");
+#ifdef ARC
+    [super dealloc];
+#endif
+}
+
+-(void)rtk_sc_close_sock
+{
+    if (![scan_socket isClosed]) {
+        //NSLog(@"m_scanner close");
+        [scan_socket close];
+    }
+}
+-(void)rtk_sc_reopen_sock
+{
+    NSError *err;
+    if ([scan_socket isClosed]) {
+        NSLog(@"m_scanner reopen");
+        scan_socket = [[AsyncUdpSocket alloc]initWithDelegate:self];
+        [scan_socket bindToPort:(LOCAL_PORT_NUM) error:&err]; //this port is udpSocket's port instead of dport
+        [scan_socket enableBroadcast:true error:&err];
+        [scan_socket receiveWithTimeout:-1 tag:0];
+    }
+}
+
+/* -------------External APIs----------------- */
+-(void)rtk_sc_build_scan_data:(unsigned int)security_level
+{
+    unsigned int len = 0;
+    unsigned char scan_buf[MAX_BUF_LEN];
+    /* Flag */
+    unsigned char flag = REQ_SCAN; // full 0 char means request to report(scan)
+    memcpy(scan_buf+len, &flag, 1);
+    len += 1;
+    
+    /* Security Level */
+    unsigned char security = security_level;
+    memcpy(scan_buf+len, &security, 1);
+    len += 1;
+    
+    /* Length: not included flag and length */
+    unsigned char length[2] = {0x0};
+    length[1] = SCAN_DATA_LEN-1-1-2; //exclude flag, security level and length
+    memcpy(scan_buf+len, length, 2);
+    len += 2;
+    
+    /* Nonce: a random value */
+    unsigned char nonce[64] = {0x0};
+    int nonce_idx = 0;
+    for (nonce_idx=0; nonce_idx<64; nonce_idx++) {
+        nonce[nonce_idx] = 65 + rand()%26;
+        //NSLog(@"[%d]: %02x", nonce_idx, nonce[nonce_idx]);
+    }
+    memcpy(scan_buf+len, nonce, 64);
+    len += 64;
+    
+    /* MD5 digest, plain buffer is nonce+default_pin */
+    unsigned char md5_result[16] = {0x0};
+    const unsigned char *default_pin_char = (const unsigned char *)[SC_SCAN_PIN cStringUsingEncoding:NSASCIIStringEncoding];
+    unsigned int default_pin_len = (unsigned int)(strlen((const char *)default_pin_char));
+    //NSLog(@"default_pin_char is(%d) %s", default_pin_len, default_pin_char);
+    unsigned char md5_buffer[64+64] = {0x0};//note: default pin max length is 64 bytes
+    memcpy(md5_buffer, nonce, 64);
+    memcpy(md5_buffer+64, default_pin_char, default_pin_len);
+    //NSLog(@"md5_plain buffer is(%d) %s", (int)strlen((const char *)md5_buffer), md5_buffer);
+    CC_MD5((const void *)md5_buffer, 64+default_pin_len , (unsigned char *)md5_result);
+    //NSLog(@"md5_encrypt result: %02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x", md5_result[0],md5_result[1],md5_result[2],md5_result[3],md5_result[4],md5_result[5],md5_result[6],md5_result[7],md5_result[8],md5_result[9],md5_result[10],md5_result[11],md5_result[12],md5_result[13],md5_result[14],md5_result[15]);
+    
+    memcpy(scan_buf+len, md5_result, 16);
+    len += 16;
+    
+    /* Source MAC Address */
+    unsigned char sa[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; // full FF means send to all possible devices
+    memcpy(scan_buf+len, sa, 6);
+    len += 6;
+    
+    /* Device Type */
+    unsigned char deviceType[2] = {0xff, 0xff};
+    memcpy(scan_buf+len, deviceType, 2);
+    len += 2;
+    
+    /* save m_scan_buf to m_discover_data */
+    NSInteger size = SCAN_DATA_LEN;
+    scan_data = [NSData dataWithBytes:(const void*)scan_buf length:size];
+#ifdef ARC
+    [scan_data retain];
+#endif
+}
+
+-(int)rtk_sc_start_scan
+{
+    int ret = RTK_FAILED;
+    unsigned int ip=0xFFFFFFFF;
+    NSError *err;
+    BOOL result;
+    NSString *host = [[NSString alloc] initWithString:[NSString stringWithFormat:@"%d.%d.%d.%d", (ip>>24)&0xFF, (ip>>16)&0xFF, (ip>>8)&0xFF, ip&0xFF]];
+
+    [scan_socket joinMulticastGroup:host error:&err];
+    [scan_socket receiveWithTimeout:-1 tag:0];
+    result = [scan_socket sendData:scan_data toHost:host  port:MCAST_PORT_NUM withTimeout:-1 tag:0];
+    if(!result)
+        ret = RTK_FAILED;
+    else
+        ret = RTK_SUCCEED;
+
+    if (ret == RTK_FAILED) {
+        NSLog(@"Finish send scan data, ret=%d", ret);
+    }
+    
+#ifdef ARC
+    [host release];
+#endif
+    
+    return ret;
+}
+
+-(NSMutableArray *)rtk_sc_get_scan_list
+{
+    return m_devlist;
+}
+
+/*-------------------UDP Delegate--------------------*/
+- (BOOL)onUdpSocket:(AsyncSocket *)sock didReceiveData:(NSData *)data withTag:(long)tag fromHost:(NSString *)host port:(UInt16)port
+{
+    if (data==nil || host==nil) {
+        return false;
+    }
+    NSLog(@"==== Scanner: receive from %@:%d ====", host, port);
+    
+    /* step 1: get the received data */
+    unsigned char flag;
+    unsigned char *data_p = (unsigned char*)[data bytes];
+    if (data_p == nil) {
+        NSLog(@"data received is nil!!!");
+        return false;
+    }
+    unsigned int data_length = (unsigned int)(data_p[2]);
+    if (data_length<RESP_MIN_LEN) {
+        NSLog(@"illegel received data with length %d", data_length);
+        return false;
+    }
+    flag = data_p[0];
+    
+#if SCANNER_DBG
+    // for debug
+    NSLog(@"data in udp is %ld bytes: ", (unsigned long)[data length]);
+    
+    int recv_idx = 0;
+    for (recv_idx=0; recv_idx<(data_length+3); recv_idx++) {
+        NSLog(@"[%d]: %02x", recv_idx, data_p[recv_idx]);
+    }
+#endif
+    
+    /* step 2: parse the data */
+    if (flag==RSP_SCAN) {
+        [self updateScanList:data_p len:data_length];
+    }
+    
+    return true;
+}
+
+-(void) build_dev_info:(struct dev_info *)new_dev data_p: (unsigned char *)data_p len: (unsigned int)len
+{
+    memcpy(new_dev->mac, data_p+ACK_OFFSET_MAC, MAC_ADDR_LEN);
+    new_dev->status = data_p[ACK_OFFSET_STATUS];
+    
+    unsigned char type_translator[2]={0x0};
+    type_translator[1] = *(data_p+ACK_OFFSET_DEV_TYPE);
+    type_translator[0] = *(data_p+ACK_OFFSET_DEV_TYPE+1);
+    memcpy(&new_dev->dev_type, type_translator, 2);
+    
+    unsigned char ip_translator[4]={0x0};
+    ip_translator[3]=*(data_p+ACK_OFFSET_IP);
+    ip_translator[2]=*(data_p+ACK_OFFSET_IP+1);
+    ip_translator[1]=*(data_p+ACK_OFFSET_IP+2);
+    ip_translator[0]=*(data_p+ACK_OFFSET_IP+3);
+    memcpy(&new_dev->ip, ip_translator, 4);
+    
+    memcpy(&new_dev->extra_info, data_p+ACK_OFFSET_DEV_NAME, len-MAC_ADDR_LEN-1-2-4);
+
+    [self dump_dev_info:new_dev];
+}
+
+-(void) dump_dev_info: (struct dev_info *)dev
+{
+#if SCANNER_DBG
+    NSLog(@"======Dump dev_info======");
+    NSLog(@"MAC: %02x:%02x:%02x:%02x:%02x:%02x", dev->mac[0], dev->mac[1],dev->mac[2],dev->mac[3],dev->mac[4],dev->mac[5]);
+    NSLog(@"Status: %d", dev->status);
+    NSLog(@"Device type: %d", dev->dev_type);
+    NSLog(@"IP:%x", dev->ip);
+    //NSLog(@"Name:%@", [NSString stringWithUTF8String:(const char *)(dev->extra_info)]);
+    NSLog(@"Name:%@", [NSString stringWithCString:(const char *)(dev->extra_info) encoding:NSUTF8StringEncoding]);
+#else
+#endif
+}
+
+/* update the received data to m_config_list */
+-(void)updateScanList: (unsigned char *)data_p len:(unsigned int)data_length
+{
+    int exist=0, i=0;
+    struct dev_info old_dev;
+    NSValue *old_dev_val;
+    struct dev_info new_dev;
+    int dev_total_num = (int)[m_devlist count];
+    
+    // no dev_info exist
+    if (dev_total_num==0)
+        goto AddNewObj;
+    
+    // OR, check if this device info already exist
+    for (i=0; i<dev_total_num; i++) {
+        old_dev_val = [m_devlist objectAtIndex:i];
+        [old_dev_val getValue:&old_dev];
+        
+        if(!memcmp(old_dev.mac, data_p+ACK_OFFSET_MAC, MAC_ADDR_LEN)){
+            // have the same mac dev in list, index is i.
+            exist = 1;
+            break;
+        }
+    }
+    
+    if (exist) {
+        // update device info
+        //NSLog(@"exist %d", i);
+        [self build_dev_info:&new_dev data_p:data_p len:data_length];
+        [m_devlist replaceObjectAtIndex:i withObject:[NSValue valueWithBytes:&new_dev objCType:@encode(struct dev_info)]];
+        return;
+    }
+    
+AddNewObj:
+    {
+        // new dev_info
+        NSLog(@"new device");
+        [self build_dev_info:&new_dev data_p:data_p len:data_length];
+        [m_devlist addObject:[NSValue valueWithBytes:&new_dev objCType:@encode(struct dev_info)]];
+        return ;
+    }
+}
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/AsyncSocket.h

@@ -0,0 +1,659 @@
+//
+//  AsyncSocket.h
+//  
+//  This class is in the public domain.
+//  Originally created by Dustin Voss on Wed Jan 29 2003.
+//  Updated and maintained by Deusty Designs and the Mac development community.
+//
+//  http://code.google.com/p/cocoaasyncsocket/
+//
+
+#import <Foundation/Foundation.h>
+
+@class AsyncSocket;
+@class AsyncReadPacket;
+@class AsyncWritePacket;
+
+extern NSString *const AsyncSocketException;
+extern NSString *const AsyncSocketErrorDomain;
+
+enum AsyncSocketError
+{
+	AsyncSocketCFSocketError = kCFSocketError,	// From CFSocketError enum.
+	AsyncSocketNoError = 0,						// Never used.
+	AsyncSocketCanceledError,					// onSocketWillConnect: returned NO.
+	AsyncSocketConnectTimeoutError,
+	AsyncSocketReadMaxedOutError,               // Reached set maxLength without completing
+	AsyncSocketReadTimeoutError,
+	AsyncSocketWriteTimeoutError
+};
+typedef enum AsyncSocketError AsyncSocketError;
+
+@protocol AsyncSocketDelegate
+@optional
+
+/**
+ * In the event of an error, the socket is closed.
+ * You may call "unreadData" during this call-back to get the last bit of data off the socket.
+ * When connecting, this delegate method may be called
+ * before"onSocket:didAcceptNewSocket:" or "onSocket:didConnectToHost:".
+**/
+- (void)onSocket:(AsyncSocket *)sock willDisconnectWithError:(NSError *)err;
+
+/**
+ * Called when a socket disconnects with or without error.  If you want to release a socket after it disconnects,
+ * do so here. It is not safe to do that during "onSocket:willDisconnectWithError:".
+ * 
+ * If you call the disconnect method, and the socket wasn't already disconnected,
+ * this delegate method will be called before the disconnect method returns.
+**/
+- (void)onSocketDidDisconnect:(AsyncSocket *)sock;
+
+/**
+ * Called when a socket accepts a connection.  Another socket is spawned to handle it. The new socket will have
+ * the same delegate and will call "onSocket:didConnectToHost:port:".
+**/
+- (void)onSocket:(AsyncSocket *)sock didAcceptNewSocket:(AsyncSocket *)newSocket;
+
+/**
+ * Called when a new socket is spawned to handle a connection.  This method should return the run-loop of the
+ * thread on which the new socket and its delegate should operate. If omitted, [NSRunLoop currentRunLoop] is used.
+**/
+- (NSRunLoop *)onSocket:(AsyncSocket *)sock wantsRunLoopForNewSocket:(AsyncSocket *)newSocket;
+
+/**
+ * Called when a socket is about to connect. This method should return YES to continue, or NO to abort.
+ * If aborted, will result in AsyncSocketCanceledError.
+ * 
+ * If the connectToHost:onPort:error: method was called, the delegate will be able to access and configure the
+ * CFReadStream and CFWriteStream as desired prior to connection.
+ *
+ * If the connectToAddress:error: method was called, the delegate will be able to access and configure the
+ * CFSocket and CFSocketNativeHandle (BSD socket) as desired prior to connection. You will be able to access and
+ * configure the CFReadStream and CFWriteStream in the onSocket:didConnectToHost:port: method.
+**/
+- (BOOL)onSocketWillConnect:(AsyncSocket *)sock;
+
+/**
+ * Called when a socket connects and is ready for reading and writing.
+ * The host parameter will be an IP address, not a DNS name.
+**/
+- (void)onSocket:(AsyncSocket *)sock didConnectToHost:(NSString *)host port:(UInt16)port;
+
+/**
+ * Called when a socket has completed reading the requested data into memory.
+ * Not called if there is an error.
+**/
+- (void)onSocket:(AsyncSocket *)sock didReadData:(NSData *)data withTag:(long)tag;
+
+/**
+ * Called when a socket has read in data, but has not yet completed the read.
+ * This would occur if using readToData: or readToLength: methods.
+ * It may be used to for things such as updating progress bars.
+**/
+- (void)onSocket:(AsyncSocket *)sock didReadPartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
+
+/**
+ * Called when a socket has completed writing the requested data. Not called if there is an error.
+**/
+- (void)onSocket:(AsyncSocket *)sock didWriteDataWithTag:(long)tag;
+
+/**
+ * Called when a socket has written some data, but has not yet completed the entire write.
+ * It may be used to for things such as updating progress bars.
+**/
+- (void)onSocket:(AsyncSocket *)sock didWritePartialDataOfLength:(NSUInteger)partialLength tag:(long)tag;
+
+/**
+ * Called if a read operation has reached its timeout without completing.
+ * This method allows you to optionally extend the timeout.
+ * If you return a positive time interval (> 0) the read's timeout will be extended by the given amount.
+ * If you don't implement this method, or return a non-positive time interval (<= 0) the read will timeout as usual.
+ * 
+ * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method.
+ * The length parameter is the number of bytes that have been read so far for the read operation.
+ * 
+ * Note that this method may be called multiple times for a single read if you return positive numbers.
+**/
+- (NSTimeInterval)onSocket:(AsyncSocket *)sock
+  shouldTimeoutReadWithTag:(long)tag
+                   elapsed:(NSTimeInterval)elapsed
+                 bytesDone:(NSUInteger)length;
+
+/**
+ * Called if a write operation has reached its timeout without completing.
+ * This method allows you to optionally extend the timeout.
+ * If you return a positive time interval (> 0) the write's timeout will be extended by the given amount.
+ * If you don't implement this method, or return a non-positive time interval (<= 0) the write will timeout as usual.
+ * 
+ * The elapsed parameter is the sum of the original timeout, plus any additions previously added via this method.
+ * The length parameter is the number of bytes that have been written so far for the write operation.
+ * 
+ * Note that this method may be called multiple times for a single write if you return positive numbers.
+**/
+- (NSTimeInterval)onSocket:(AsyncSocket *)sock
+ shouldTimeoutWriteWithTag:(long)tag
+                   elapsed:(NSTimeInterval)elapsed
+                 bytesDone:(NSUInteger)length;
+
+/**
+ * Called after the socket has successfully completed SSL/TLS negotiation.
+ * This method is not called unless you use the provided startTLS method.
+ * 
+ * If a SSL/TLS negotiation fails (invalid certificate, etc) then the socket will immediately close,
+ * and the onSocket:willDisconnectWithError: delegate method will be called with the specific SSL error code.
+**/
+- (void)onSocketDidSecure:(AsyncSocket *)sock;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface AsyncSocket : NSObject
+{
+	CFSocketNativeHandle theNativeSocket4;
+	CFSocketNativeHandle theNativeSocket6;
+	
+	CFSocketRef theSocket4;            // IPv4 accept or connect socket
+	CFSocketRef theSocket6;            // IPv6 accept or connect socket
+	
+	CFReadStreamRef theReadStream;
+	CFWriteStreamRef theWriteStream;
+
+	CFRunLoopSourceRef theSource4;     // For theSocket4
+	CFRunLoopSourceRef theSource6;     // For theSocket6
+	CFRunLoopRef theRunLoop;
+	CFSocketContext theContext;
+	NSArray *theRunLoopModes;
+	
+	NSTimer *theConnectTimer;
+
+	NSMutableArray *theReadQueue;
+	AsyncReadPacket *theCurrentRead;
+	NSTimer *theReadTimer;
+	NSMutableData *partialReadBuffer;
+	
+	NSMutableArray *theWriteQueue;
+	AsyncWritePacket *theCurrentWrite;
+	NSTimer *theWriteTimer;
+
+	id theDelegate;
+	UInt16 theFlags;
+	
+	long theUserData;
+}
+
+- (id)init;
+- (id)initWithDelegate:(id)delegate;
+- (id)initWithDelegate:(id)delegate userData:(long)userData;
+
+/* String representation is long but has no "\n". */
+- (NSString *)description;
+
+/**
+ * Use "canSafelySetDelegate" to see if there is any pending business (reads and writes) with the current delegate
+ * before changing it.  It is, of course, safe to change the delegate before connecting or accepting connections.
+**/
+- (id)delegate;
+- (BOOL)canSafelySetDelegate;
+- (void)setDelegate:(id)delegate;
+
+/* User data can be a long, or an id or void * cast to a long. */
+- (long)userData;
+- (void)setUserData:(long)userData;
+
+/* Don't use these to read or write. And don't close them either! */
+- (CFSocketRef)getCFSocket;
+- (CFReadStreamRef)getCFReadStream;
+- (CFWriteStreamRef)getCFWriteStream;
+
+// Once one of the accept or connect methods are called, the AsyncSocket instance is locked in
+// and the other accept/connect methods can't be called without disconnecting the socket first.
+// If the attempt fails or times out, these methods either return NO or
+// call "onSocket:willDisconnectWithError:" and "onSockedDidDisconnect:".
+
+// When an incoming connection is accepted, AsyncSocket invokes several delegate methods.
+// These methods are (in chronological order):
+// 1. onSocket:didAcceptNewSocket:
+// 2. onSocket:wantsRunLoopForNewSocket:
+// 3. onSocketWillConnect:
+// 
+// Your server code will need to retain the accepted socket (if you want to accept it).
+// The best place to do this is probably in the onSocket:didAcceptNewSocket: method.
+// 
+// After the read and write streams have been setup for the newly accepted socket,
+// the onSocket:didConnectToHost:port: method will be called on the proper run loop.
+// 
+// Multithreading Note: If you're going to be moving the newly accepted socket to another run
+// loop by implementing onSocket:wantsRunLoopForNewSocket:, then you should wait until the
+// onSocket:didConnectToHost:port: method before calling read, write, or startTLS methods.
+// Otherwise read/write events are scheduled on the incorrect runloop, and chaos may ensue.
+
+/**
+ * Tells the socket to begin listening and accepting connections on the given port.
+ * When a connection comes in, the AsyncSocket instance will call the various delegate methods (see above).
+ * The socket will listen on all available interfaces (e.g. wifi, ethernet, etc)
+**/
+- (BOOL)acceptOnPort:(UInt16)port error:(NSError **)errPtr;
+
+/**
+ * This method is the same as acceptOnPort:error: with the additional option
+ * of specifying which interface to listen on. So, for example, if you were writing code for a server that
+ * has multiple IP addresses, you could specify which address you wanted to listen on.  Or you could use it
+ * to specify that the socket should only accept connections over ethernet, and not other interfaces such as wifi.
+ * You may also use the special strings "localhost" or "loopback" to specify that
+ * the socket only accept connections from the local machine.
+ * 
+ * To accept connections on any interface pass nil, or simply use the acceptOnPort:error: method.
+**/
+- (BOOL)acceptOnInterface:(NSString *)interface port:(UInt16)port error:(NSError **)errPtr;
+
+/**
+ * Connects to the given host and port.
+ * The host may be a domain name (e.g. "deusty.com") or an IP address string (e.g. "192.168.0.2")
+**/
+- (BOOL)connectToHost:(NSString *)hostname onPort:(UInt16)port error:(NSError **)errPtr;
+
+/**
+ * This method is the same as connectToHost:onPort:error: with an additional timeout option.
+ * To not time out use a negative time interval, or simply use the connectToHost:onPort:error: method.
+**/
+- (BOOL)connectToHost:(NSString *)hostname
+               onPort:(UInt16)port
+          withTimeout:(NSTimeInterval)timeout
+                error:(NSError **)errPtr;
+
+/**
+ * Connects to the given address, specified as a sockaddr structure wrapped in a NSData object.
+ * For example, a NSData object returned from NSNetService's addresses method.
+ * 
+ * If you have an existing struct sockaddr you can convert it to a NSData object like so:
+ * struct sockaddr sa  -> NSData *dsa = [NSData dataWithBytes:&remoteAddr length:remoteAddr.sa_len];
+ * struct sockaddr *sa -> NSData *dsa = [NSData dataWithBytes:remoteAddr length:remoteAddr->sa_len];
+**/
+- (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr;
+
+/**
+ * This method is the same as connectToAddress:error: with an additional timeout option.
+ * To not time out use a negative time interval, or simply use the connectToAddress:error: method.
+**/
+- (BOOL)connectToAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeout error:(NSError **)errPtr;
+
+- (BOOL)connectToAddress:(NSData *)remoteAddr
+     viaInterfaceAddress:(NSData *)interfaceAddr
+             withTimeout:(NSTimeInterval)timeout
+                   error:(NSError **)errPtr;
+
+/**
+ * Disconnects immediately. Any pending reads or writes are dropped.
+ * If the socket is not already disconnected, the onSocketDidDisconnect delegate method
+ * will be called immediately, before this method returns.
+ * 
+ * Please note the recommended way of releasing an AsyncSocket instance (e.g. in a dealloc method)
+ * [asyncSocket setDelegate:nil];
+ * [asyncSocket disconnect];
+ * [asyncSocket release];
+**/
+- (void)disconnect;
+
+/**
+ * Disconnects after all pending reads have completed.
+ * After calling this, the read and write methods will do nothing.
+ * The socket will disconnect even if there are still pending writes.
+**/
+- (void)disconnectAfterReading;
+
+/**
+ * Disconnects after all pending writes have completed.
+ * After calling this, the read and write methods will do nothing.
+ * The socket will disconnect even if there are still pending reads.
+**/
+- (void)disconnectAfterWriting;
+
+/**
+ * Disconnects after all pending reads and writes have completed.
+ * After calling this, the read and write methods will do nothing.
+**/
+- (void)disconnectAfterReadingAndWriting;
+
+/* Returns YES if the socket and streams are open, connected, and ready for reading and writing. */
+- (BOOL)isConnected;
+
+/**
+ * Returns the local or remote host and port to which this socket is connected, or nil and 0 if not connected.
+ * The host will be an IP address.
+**/
+- (NSString *)connectedHost;
+- (UInt16)connectedPort;
+
+- (NSString *)localHost;
+- (UInt16)localPort;
+
+/**
+ * Returns the local or remote address to which this socket is connected,
+ * specified as a sockaddr structure wrapped in a NSData object.
+ * 
+ * See also the connectedHost, connectedPort, localHost and localPort methods.
+**/
+- (NSData *)connectedAddress;
+- (NSData *)localAddress;
+
+/**
+ * Returns whether the socket is IPv4 or IPv6.
+ * An accepting socket may be both.
+**/
+- (BOOL)isIPv4;
+- (BOOL)isIPv6;
+
+// The readData and writeData methods won't block (they are asynchronous).
+// 
+// When a read is complete the onSocket:didReadData:withTag: delegate method is called.
+// When a write is complete the onSocket:didWriteDataWithTag: delegate method is called.
+// 
+// You may optionally set a timeout for any read/write operation. (To not timeout, use a negative time interval.)
+// If a read/write opertion times out, the corresponding "onSocket:shouldTimeout..." delegate method
+// is called to optionally allow you to extend the timeout.
+// Upon a timeout, the "onSocket:willDisconnectWithError:" method is called, followed by "onSocketDidDisconnect".
+// 
+// The tag is for your convenience.
+// You can use it as an array index, step number, state id, pointer, etc.
+
+/**
+ * Reads the first available bytes that become available on the socket.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+**/
+- (void)readDataWithTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Reads the first available bytes that become available on the socket.
+ * The bytes will be appended to the given byte buffer starting at the given offset.
+ * The given buffer will automatically be increased in size if needed.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * If the buffer if nil, the socket will create a buffer for you.
+ * 
+ * If the bufferOffset is greater than the length of the given buffer,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * After completion, the data returned in onSocket:didReadData:withTag: will be a subset of the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer.
+**/
+- (void)readDataWithTimeout:(NSTimeInterval)timeout
+                     buffer:(NSMutableData *)buffer
+               bufferOffset:(NSUInteger)offset
+                        tag:(long)tag;
+
+/**
+ * Reads the first available bytes that become available on the socket.
+ * The bytes will be appended to the given byte buffer starting at the given offset.
+ * The given buffer will automatically be increased in size if needed.
+ * A maximum of length bytes will be read.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * If the buffer if nil, a buffer will automatically be created for you.
+ * If maxLength is zero, no length restriction is enforced.
+ * 
+ * If the bufferOffset is greater than the length of the given buffer,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * After completion, the data returned in onSocket:didReadData:withTag: will be a subset of the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer.
+**/
+- (void)readDataWithTimeout:(NSTimeInterval)timeout
+                     buffer:(NSMutableData *)buffer
+               bufferOffset:(NSUInteger)offset
+                  maxLength:(NSUInteger)length
+                        tag:(long)tag;
+
+/**
+ * Reads the given number of bytes.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * 
+ * If the length is 0, this method does nothing and the delegate is not called.
+**/
+- (void)readDataToLength:(NSUInteger)length withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Reads the given number of bytes.
+ * The bytes will be appended to the given byte buffer starting at the given offset.
+ * The given buffer will automatically be increased in size if needed.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * If the buffer if nil, a buffer will automatically be created for you.
+ * 
+ * If the length is 0, this method does nothing and the delegate is not called.
+ * If the bufferOffset is greater than the length of the given buffer,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * After completion, the data returned in onSocket:didReadData:withTag: will be a subset of the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer.
+**/
+- (void)readDataToLength:(NSUInteger)length
+             withTimeout:(NSTimeInterval)timeout
+                  buffer:(NSMutableData *)buffer
+            bufferOffset:(NSUInteger)offset
+                     tag:(long)tag;
+
+/**
+ * Reads bytes until (and including) the passed "data" parameter, which acts as a separator.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * 
+ * If you pass nil or zero-length data as the "data" parameter,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
+ * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
+ * a character, the read will prematurely end.
+**/
+- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Reads bytes until (and including) the passed "data" parameter, which acts as a separator.
+ * The bytes will be appended to the given byte buffer starting at the given offset.
+ * The given buffer will automatically be increased in size if needed.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * If the buffer if nil, a buffer will automatically be created for you.
+ * 
+ * If the bufferOffset is greater than the length of the given buffer,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * After completion, the data returned in onSocket:didReadData:withTag: will be a subset of the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer.
+ * 
+ * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
+ * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
+ * a character, the read will prematurely end.
+**/
+- (void)readDataToData:(NSData *)data
+           withTimeout:(NSTimeInterval)timeout
+                buffer:(NSMutableData *)buffer
+          bufferOffset:(NSUInteger)offset
+                   tag:(long)tag;
+
+/**
+ * Reads bytes until (and including) the passed "data" parameter, which acts as a separator.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * 
+ * If maxLength is zero, no length restriction is enforced.
+ * Otherwise if maxLength bytes are read without completing the read,
+ * it is treated similarly to a timeout - the socket is closed with a AsyncSocketReadMaxedOutError.
+ * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
+ * 
+ * If you pass nil or zero-length data as the "data" parameter,
+ * the method will do nothing, and the delegate will not be called.
+ * If you pass a maxLength parameter that is less than the length of the data parameter,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
+ * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
+ * a character, the read will prematurely end.
+**/
+- (void)readDataToData:(NSData *)data withTimeout:(NSTimeInterval)timeout maxLength:(NSUInteger)length tag:(long)tag;
+
+/**
+ * Reads bytes until (and including) the passed "data" parameter, which acts as a separator.
+ * The bytes will be appended to the given byte buffer starting at the given offset.
+ * The given buffer will automatically be increased in size if needed.
+ * A maximum of length bytes will be read.
+ * 
+ * If the timeout value is negative, the read operation will not use a timeout.
+ * If the buffer if nil, a buffer will automatically be created for you.
+ * 
+ * If maxLength is zero, no length restriction is enforced.
+ * Otherwise if maxLength bytes are read without completing the read,
+ * it is treated similarly to a timeout - the socket is closed with a AsyncSocketReadMaxedOutError.
+ * The read will complete successfully if exactly maxLength bytes are read and the given data is found at the end.
+ * 
+ * If you pass a maxLength parameter that is less than the length of the data parameter,
+ * the method will do nothing, and the delegate will not be called.
+ * If the bufferOffset is greater than the length of the given buffer,
+ * the method will do nothing, and the delegate will not be called.
+ * 
+ * If you pass a buffer, you must not alter it in any way while AsyncSocket is using it.
+ * After completion, the data returned in onSocket:didReadData:withTag: will be a subset of the given buffer.
+ * That is, it will reference the bytes that were appended to the given buffer.
+ * 
+ * To read a line from the socket, use the line separator (e.g. CRLF for HTTP, see below) as the "data" parameter.
+ * Note that this method is not character-set aware, so if a separator can occur naturally as part of the encoding for
+ * a character, the read will prematurely end.
+**/
+- (void)readDataToData:(NSData *)data
+           withTimeout:(NSTimeInterval)timeout
+                buffer:(NSMutableData *)buffer
+          bufferOffset:(NSUInteger)offset
+             maxLength:(NSUInteger)length
+                   tag:(long)tag;
+
+/**
+ * Writes data to the socket, and calls the delegate when finished.
+ * 
+ * If you pass in nil or zero-length data, this method does nothing and the delegate will not be called.
+ * If the timeout value is negative, the write operation will not use a timeout.
+**/
+- (void)writeData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Returns progress of current read or write, from 0.0 to 1.0, or NaN if no read/write (use isnan() to check).
+ * "tag", "done" and "total" will be filled in if they aren't NULL.
+**/
+- (float)progressOfReadReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
+- (float)progressOfWriteReturningTag:(long *)tag bytesDone:(NSUInteger *)done total:(NSUInteger *)total;
+
+/**
+ * Secures the connection using SSL/TLS.
+ * 
+ * This method may be called at any time, and the TLS handshake will occur after all pending reads and writes
+ * are finished. This allows one the option of sending a protocol dependent StartTLS message, and queuing
+ * the upgrade to TLS at the same time, without having to wait for the write to finish.
+ * Any reads or writes scheduled after this method is called will occur over the secured connection.
+ * 
+ * The possible keys and values for the TLS settings are well documented.
+ * Some possible keys are:
+ * - kCFStreamSSLLevel
+ * - kCFStreamSSLAllowsExpiredCertificates
+ * - kCFStreamSSLAllowsExpiredRoots
+ * - kCFStreamSSLAllowsAnyRoot
+ * - kCFStreamSSLValidatesCertificateChain
+ * - kCFStreamSSLPeerName
+ * - kCFStreamSSLCertificates
+ * - kCFStreamSSLIsServer
+ * 
+ * Please refer to Apple's documentation for associated values, as well as other possible keys.
+ * 
+ * If you pass in nil or an empty dictionary, the default settings will be used.
+ * 
+ * The default settings will check to make sure the remote party's certificate is signed by a
+ * trusted 3rd party certificate agency (e.g. verisign) and that the certificate is not expired.
+ * However it will not verify the name on the certificate unless you
+ * give it a name to verify against via the kCFStreamSSLPeerName key.
+ * The security implications of this are important to understand.
+ * Imagine you are attempting to create a secure connection to MySecureServer.com,
+ * but your socket gets directed to MaliciousServer.com because of a hacked DNS server.
+ * If you simply use the default settings, and MaliciousServer.com has a valid certificate,
+ * the default settings will not detect any problems since the certificate is valid.
+ * To properly secure your connection in this particular scenario you
+ * should set the kCFStreamSSLPeerName property to "MySecureServer.com".
+ * If you do not know the peer name of the remote host in advance (for example, you're not sure
+ * if it will be "domain.com" or "www.domain.com"), then you can use the default settings to validate the
+ * certificate, and then use the X509Certificate class to verify the issuer after the socket has been secured.
+ * The X509Certificate class is part of the CocoaAsyncSocket open source project.
+**/
+- (void)startTLS:(NSDictionary *)tlsSettings;
+
+/**
+ * For handling readDataToData requests, data is necessarily read from the socket in small increments.
+ * The performance can be much improved by allowing AsyncSocket to read larger chunks at a time and
+ * store any overflow in a small internal buffer.
+ * This is termed pre-buffering, as some data may be read for you before you ask for it.
+ * If you use readDataToData a lot, enabling pre-buffering will result in better performance, especially on the iPhone.
+ * 
+ * The default pre-buffering state is controlled by the DEFAULT_PREBUFFERING definition.
+ * It is highly recommended one leave this set to YES.
+ * 
+ * This method exists in case pre-buffering needs to be disabled by default for some unforeseen reason.
+ * In that case, this method exists to allow one to easily enable pre-buffering when ready.
+**/
+- (void)enablePreBuffering;
+
+/**
+ * When you create an AsyncSocket, it is added to the runloop of the current thread.
+ * So for manually created sockets, it is easiest to simply create the socket on the thread you intend to use it.
+ * 
+ * If a new socket is accepted, the delegate method onSocket:wantsRunLoopForNewSocket: is called to
+ * allow you to place the socket on a separate thread. This works best in conjunction with a thread pool design.
+ * 
+ * If, however, you need to move the socket to a separate thread at a later time, this
+ * method may be used to accomplish the task.
+ * 
+ * This method must be called from the thread/runloop the socket is currently running on.
+ * 
+ * Note: After calling this method, all further method calls to this object should be done from the given runloop.
+ * Also, all delegate calls will be sent on the given runloop.
+**/
+- (BOOL)moveToRunLoop:(NSRunLoop *)runLoop;
+
+/**
+ * Allows you to configure which run loop modes the socket uses.
+ * The default set of run loop modes is NSDefaultRunLoopMode.
+ * 
+ * If you'd like your socket to continue operation during other modes, you may want to add modes such as
+ * NSModalPanelRunLoopMode or NSEventTrackingRunLoopMode. Or you may simply want to use NSRunLoopCommonModes.
+ * 
+ * Accepted sockets will automatically inherit the same run loop modes as the listening socket.
+ * 
+ * Note: NSRunLoopCommonModes is defined in 10.5. For previous versions one can use kCFRunLoopCommonModes.
+**/
+- (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
+- (BOOL)addRunLoopMode:(NSString *)runLoopMode;
+- (BOOL)removeRunLoopMode:(NSString *)runLoopMode;
+
+/**
+ * Returns the current run loop modes the AsyncSocket instance is operating in.
+ * The default set of run loop modes is NSDefaultRunLoopMode.
+**/
+- (NSArray *)runLoopModes;
+
+/**
+ * In the event of an error, this method may be called during onSocket:willDisconnectWithError: to read
+ * any data that's left on the socket.
+**/
+- (NSData *)unreadData;
+
+/* A few common line separators, for use with the readDataToData:... methods. */
++ (NSData *)CRLFData;   // 0x0D0A
++ (NSData *)CRData;     // 0x0D
++ (NSData *)LFData;     // 0x0A
++ (NSData *)ZeroData;   // 0x00
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/AsyncUdpSocket.h

@@ -0,0 +1,366 @@
+//
+//  AsyncUdpSocket.h
+//  
+//  This class is in the public domain.
+//  Originally created by Robbie Hanson on Wed Oct 01 2008.
+//  Updated and maintained by Deusty Designs and the Mac development community.
+//
+//  http://code.google.com/p/cocoaasyncsocket/
+//
+
+#import <Foundation/Foundation.h>
+
+@class AsyncSendPacket;
+@class AsyncReceivePacket;
+
+extern NSString *const AsyncUdpSocketException;
+extern NSString *const AsyncUdpSocketErrorDomain;
+
+enum AsyncUdpSocketError
+{
+	AsyncUdpSocketCFSocketError = kCFSocketError,	// From CFSocketError enum
+	AsyncUdpSocketNoError = 0,						// Never used
+	AsyncUdpSocketBadParameter,                     // Used if given a bad parameter (such as an improper address)
+	AsyncUdpSocketIPv4Unavailable,                  // Used if you bind/connect using IPv6 only
+	AsyncUdpSocketIPv6Unavailable,                  // Used if you bind/connect using IPv4 only (or iPhone)
+	AsyncUdpSocketSendTimeoutError,
+	AsyncUdpSocketReceiveTimeoutError
+};
+typedef enum AsyncUdpSocketError AsyncUdpSocketError;
+
+@interface AsyncUdpSocket : NSObject
+{
+	CFSocketRef theSocket4;            // IPv4 socket
+	CFSocketRef theSocket6;            // IPv6 socket
+	
+	CFRunLoopSourceRef theSource4;     // For theSocket4
+	CFRunLoopSourceRef theSource6;     // For theSocket6
+	CFRunLoopRef theRunLoop;
+	CFSocketContext theContext;
+	NSArray *theRunLoopModes;
+	
+	NSMutableArray *theSendQueue;
+	AsyncSendPacket *theCurrentSend;
+	NSTimer *theSendTimer;
+	
+	NSMutableArray *theReceiveQueue;
+	AsyncReceivePacket *theCurrentReceive;
+	NSTimer *theReceiveTimer;
+	
+	id theDelegate;
+	UInt16 theFlags;
+	
+	long theUserData;
+	
+	NSString *cachedLocalHost;
+	UInt16 cachedLocalPort;
+	
+	NSString *cachedConnectedHost;
+	UInt16 cachedConnectedPort;
+	
+	UInt32 maxReceiveBufferSize;
+}
+
+/**
+ * Creates new instances of AsyncUdpSocket.
+**/
+- (id)init;
+- (id)initWithDelegate:(id)delegate;
+- (id)initWithDelegate:(id)delegate userData:(long)userData;
+
+/**
+ * Creates new instances of AsyncUdpSocket that support only IPv4 or IPv6.
+ * The other init methods will support both, unless specifically binded or connected to one protocol.
+ * If you know you'll only be using one protocol, these init methods may be a bit more efficient.
+**/
+- (id)initIPv4;
+- (id)initIPv6;
+
+- (id)delegate;
+- (void)setDelegate:(id)delegate;
+
+- (long)userData;
+- (void)setUserData:(long)userData;
+
+/**
+ * Returns the local address info for the socket.
+ * 
+ * Note: Address info may not be available until after the socket has been bind'ed,
+ * or until after data has been sent.
+**/
+- (NSString *)localHost;
+- (UInt16)localPort;
+
+/**
+ * Returns the remote address info for the socket.
+ * 
+ * Note: Since UDP is connectionless by design, connected address info
+ * will not be available unless the socket is explicitly connected to a remote host/port
+**/
+- (NSString *)connectedHost;
+- (UInt16)connectedPort;
+
+/**
+ * Returns whether or not this socket has been connected to a single host.
+ * By design, UDP is a connectionless protocol, and connecting is not needed.
+ * If connected, the socket will only be able to send/receive data to/from the connected host.
+**/
+- (BOOL)isConnected;
+
+/**
+ * Returns whether or not this socket has been closed.
+ * The only way a socket can be closed is if you explicitly call one of the close methods.
+**/
+- (BOOL)isClosed;
+
+/**
+ * Returns whether or not this socket supports IPv4.
+ * By default this will be true, unless the socket is specifically initialized as IPv6 only,
+ * or is binded or connected to an IPv6 address.
+**/
+- (BOOL)isIPv4;
+
+/**
+ * Returns whether or not this socket supports IPv6.
+ * By default this will be true, unless the socket is specifically initialized as IPv4 only,
+ * or is binded or connected to an IPv4 address.
+ * 
+ * This method will also return false on platforms that do not support IPv6.
+ * Note: The iPhone does not currently support IPv6.
+**/
+- (BOOL)isIPv6;
+
+/**
+ * Returns the mtu of the socket.
+ * If unknown, returns zero.
+ * 
+ * Sending data larger than this may result in an error.
+ * This is an advanced topic, and one should understand the wide range of mtu's on networks and the internet.
+ * Therefore this method is only for reference and may be of little use in many situations.
+**/
+- (unsigned int)maximumTransmissionUnit;
+
+/**
+ * Binds the UDP socket to the given port and optional address.
+ * Binding should be done for server sockets that receive data prior to sending it.
+ * Client sockets can skip binding,
+ * as the OS will automatically assign the socket an available port when it starts sending data.
+ * 
+ * You cannot bind a socket after its been connected.
+ * You can only bind a socket once.
+ * You can still connect a socket (if desired) after binding.
+ * 
+ * On success, returns YES.
+ * Otherwise returns NO, and sets errPtr. If you don't care about the error, you can pass nil for errPtr.
+**/
+- (BOOL)bindToPort:(UInt16)port error:(NSError **)errPtr;
+- (BOOL)bindToAddress:(NSString *)localAddr port:(UInt16)port error:(NSError **)errPtr;
+
+/**
+ * Connects the UDP socket to the given host and port.
+ * By design, UDP is a connectionless protocol, and connecting is not needed.
+ * 
+ * Choosing to connect to a specific host/port has the following effect:
+ * - You will only be able to send data to the connected host/port.
+ * - You will only be able to receive data from the connected host/port.
+ * - You will receive ICMP messages that come from the connected host/port, such as "connection refused".
+ * 
+ * Connecting a UDP socket does not result in any communication on the socket.
+ * It simply changes the internal state of the socket.
+ * 
+ * You cannot bind a socket after its been connected.
+ * You can only connect a socket once.
+ * 
+ * On success, returns YES.
+ * Otherwise returns NO, and sets errPtr. If you don't care about the error, you can pass nil for errPtr.
+**/
+- (BOOL)connectToHost:(NSString *)host onPort:(UInt16)port error:(NSError **)errPtr;
+- (BOOL)connectToAddress:(NSData *)remoteAddr error:(NSError **)errPtr;
+
+/**
+ * Join multicast group
+ *
+ * Group should be an IP address (eg @"225.228.0.1")
+**/
+- (BOOL)joinMulticastGroup:(NSString *)group error:(NSError **)errPtr;
+- (BOOL)joinMulticastGroup:(NSString *)group withAddress:(NSString *)interface error:(NSError **)errPtr;
+
+/**
+ * By default, the underlying socket in the OS will not allow you to send broadcast messages.
+ * In order to send broadcast messages, you need to enable this functionality in the socket.
+ * 
+ * A broadcast is a UDP message to addresses like "192.168.255.255" or "255.255.255.255" that is
+ * delivered to every host on the network.
+ * The reason this is generally disabled by default is to prevent
+ * accidental broadcast messages from flooding the network.
+**/
+- (BOOL)enableBroadcast:(BOOL)flag error:(NSError **)errPtr;
+
+/**
+ * Asynchronously sends the given data, with the given timeout and tag.
+ * 
+ * This method may only be used with a connected socket.
+ * 
+ * If data is nil or zero-length, this method does nothing and immediately returns NO.
+ * If the socket is not connected, this method does nothing and immediately returns NO.
+**/
+- (BOOL)sendData:(NSData *)data withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Asynchronously sends the given data, with the given timeout and tag, to the given host and port.
+ * 
+ * This method cannot be used with a connected socket.
+ * 
+ * If data is nil or zero-length, this method does nothing and immediately returns NO.
+ * If the socket is connected, this method does nothing and immediately returns NO.
+ * If unable to resolve host to a valid IPv4 or IPv6 address, this method returns NO.
+**/
+- (BOOL)sendData:(NSData *)data toHost:(NSString *)host port:(UInt16)port withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Asynchronously sends the given data, with the given timeout and tag, to the given address.
+ * 
+ * This method cannot be used with a connected socket.
+ * 
+ * If data is nil or zero-length, this method does nothing and immediately returns NO.
+ * If the socket is connected, this method does nothing and immediately returns NO.
+**/
+- (BOOL)sendData:(NSData *)data toAddress:(NSData *)remoteAddr withTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Asynchronously receives a single datagram packet.
+ * 
+ * If the receive succeeds, the onUdpSocket:didReceiveData:fromHost:port:tag delegate method will be called.
+ * Otherwise, a timeout will occur, and the onUdpSocket:didNotReceiveDataWithTag: delegate method will be called.
+**/
+- (void)receiveWithTimeout:(NSTimeInterval)timeout tag:(long)tag;
+
+/**
+ * Closes the socket immediately. Any pending send or receive operations are dropped.
+**/
+- (void)close;
+
+/**
+ * Closes after all pending send operations have completed.
+ * After calling this, the sendData: and receive: methods will do nothing.
+ * In other words, you won't be able to add any more send or receive operations to the queue.
+ * The socket will close even if there are still pending receive operations.
+**/
+- (void)closeAfterSending;
+
+/**
+ * Closes after all pending receive operations have completed.
+ * After calling this, the sendData: and receive: methods will do nothing.
+ * In other words, you won't be able to add any more send or receive operations to the queue.
+ * The socket will close even if there are still pending send operations.
+**/
+- (void)closeAfterReceiving;
+
+/**
+ * Closes after all pending send and receive operations have completed.
+ * After calling this, the sendData: and receive: methods will do nothing.
+ * In other words, you won't be able to add any more send or receive operations to the queue.
+**/
+- (void)closeAfterSendingAndReceiving;
+
+/**
+ * Gets/Sets the maximum size of the buffer that will be allocated for receive operations.
+ * The default size is 9216 bytes.
+ * 
+ * The theoretical maximum size of any IPv4 UDP packet is UINT16_MAX = 65535.
+ * The theoretical maximum size of any IPv6 UDP packet is UINT32_MAX = 4294967295.
+ * 
+ * In practice, however, the size of UDP packets will be much smaller.
+ * Indeed most protocols will send and receive packets of only a few bytes,
+ * or will set a limit on the size of packets to prevent fragmentation in the IP layer.
+ * 
+ * If you set the buffer size too small, the sockets API in the OS will silently discard
+ * any extra data, and you will not be notified of the error.
+**/
+- (UInt32)maxReceiveBufferSize;
+- (void)setMaxReceiveBufferSize:(UInt32)max;
+
+/**
+ * When you create an AsyncUdpSocket, it is added to the runloop of the current thread.
+ * So it is easiest to simply create the socket on the thread you intend to use it.
+ * 
+ * If, however, you need to move the socket to a separate thread at a later time, this
+ * method may be used to accomplish the task.
+ * 
+ * This method must be called from the thread/runloop the socket is currently running on.
+ * 
+ * Note: After calling this method, all further method calls to this object should be done from the given runloop.
+ * Also, all delegate calls will be sent on the given runloop.
+**/
+- (BOOL)moveToRunLoop:(NSRunLoop *)runLoop;
+
+/**
+ * Allows you to configure which run loop modes the socket uses.
+ * The default set of run loop modes is NSDefaultRunLoopMode.
+ * 
+ * If you'd like your socket to continue operation during other modes, you may want to add modes such as
+ * NSModalPanelRunLoopMode or NSEventTrackingRunLoopMode. Or you may simply want to use NSRunLoopCommonModes.
+ * 
+ * Note: NSRunLoopCommonModes is defined in 10.5. For previous versions one can use kCFRunLoopCommonModes.
+**/
+- (BOOL)setRunLoopModes:(NSArray *)runLoopModes;
+
+/**
+ * Returns the current run loop modes the AsyncSocket instance is operating in.
+ * The default set of run loop modes is NSDefaultRunLoopMode.
+**/
+- (NSArray *)runLoopModes;
+
+@end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@protocol AsyncUdpSocketDelegate
+@optional
+
+/**
+ * Called when the datagram with the given tag has been sent.
+**/
+- (void)onUdpSocket:(AsyncUdpSocket *)sock didSendDataWithTag:(long)tag;
+
+/**
+ * Called if an error occurs while trying to send a datagram.
+ * This could be due to a timeout, or something more serious such as the data being too large to fit in a sigle packet.
+**/
+- (void)onUdpSocket:(AsyncUdpSocket *)sock didNotSendDataWithTag:(long)tag dueToError:(NSError *)error;
+
+/**
+ * Called when the socket has received the requested datagram.
+ * 
+ * Due to the nature of UDP, you may occasionally receive undesired packets.
+ * These may be rogue UDP packets from unknown hosts,
+ * or they may be delayed packets arriving after retransmissions have already occurred.
+ * It's important these packets are properly ignored, while not interfering with the flow of your implementation.
+ * As an aid, this delegate method has a boolean return value.
+ * If you ever need to ignore a received packet, simply return NO,
+ * and AsyncUdpSocket will continue as if the packet never arrived.
+ * That is, the original receive request will still be queued, and will still timeout as usual if a timeout was set.
+ * For example, say you requested to receive data, and you set a timeout of 500 milliseconds, using a tag of 15.
+ * If rogue data arrives after 250 milliseconds, this delegate method would be invoked, and you could simply return NO.
+ * If the expected data then arrives within the next 250 milliseconds,
+ * this delegate method will be invoked, with a tag of 15, just as if the rogue data never appeared.
+ * 
+ * Under normal circumstances, you simply return YES from this method.
+**/
+- (BOOL)onUdpSocket:(AsyncUdpSocket *)sock didReceiveData:(NSData *)data withTag:(long)tag fromHost:(NSString *)host port:(UInt16)port;
+
+/**
+ * Called if an error occurs while trying to receive a requested datagram.
+ * This is generally due to a timeout, but could potentially be something else if some kind of OS error occurred.
+**/
+- (void)onUdpSocket:(AsyncUdpSocket *)sock didNotReceiveDataWithTag:(long)tag dueToError:(NSError *)error;
+
+/**
+ * Called when the socket is closed.
+ * A socket is only closed if you explicitly call one of the close methods.
+**/
+- (void)onUdpSocketDidClose:(AsyncUdpSocket *)sock;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/Defines.h

@@ -0,0 +1,117 @@
+//
+//  defines.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/6.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#ifndef SimpleConfig_defines_h
+#define SimpleConfig_defines_h
+
+#define APP_DEBUG
+#ifdef APP_DEBUG
+#define NSLog(...) NSLog(__VA_ARGS__)
+#else
+#define NSLog(...) do {} while (0)
+#endif
+
+#define PATTERN_ONE                 0
+#define PATTERN_TWO                 1
+#define PATTERN_THREE               2
+#define PATTERN_FOUR                3
+
+#define PATTERN_DEF_PIN             @"57289961"
+
+#define PATTERN_ONE_IDX             (PATTERN_ONE+1)
+#define PATTERN_TWO_IDX             (PATTERN_TWO+1)
+#define PATTERN_THREE_IDX           (PATTERN_THREE+1)
+#define PATTERN_FOUR_IDX            (PATTERN_FOUR+1)
+
+#define RTK_FAILED                  (-1)
+#define RTK_SUCCEED                 (0)
+
+#define RTK_SC_CONTROL_SAVE         (0)                         // deprecated
+#define RTK_SC_CONTROL_RENAME       (1)
+#define RTK_SC_CONTROL_DELETE       (2)
+
+#define SC_RAND_MIN                 (48)
+#define SC_RAND_MAX                 (255)
+#define MCAST_ADDR_PREFIX           (239)
+
+#define BIT(x)                      (1<<(x))
+#define PATTERN_VALID               BIT(1)
+#define PATTERN_HAS_END             BIT(2)
+#define PATTERN_USING_UDP_SOCKET    BIT(3)
+#define PATTERN_USING_PLAIN         BIT(4)
+
+#define TLV_T_BYTES                 (1)
+#define TLV_L_BYTES                 (1)
+#define TLV_T_L_BYTES               (TLV_T_BYTES + TLV_L_BYTES)
+#define TAG_SSID                    1
+#define TAG_PSW                     2
+#define TAG_IP                      3
+
+#define MAX_AES_KEY_LEN             (32)
+#define MAX_BUF_LEN                 (256)
+
+#define SCAN_DATA_LEN               (1+1+2+64+16+6+2)
+#define CONTROL_DATA_LEN            (1+1+2+64+16+16)
+#define ACK_TO_CONTROL_DATA_LEN     (1+1+2+64+16+16+1)
+#define RESP_MIN_LEN                (1+2+6+1+2+4)
+#define CONTROL_ACK_ACK_LEN         (64+16+16+1)
+#define SCAN_PACKET_SEND_TIME       (3)
+#define CONTROL_PACKET_SEND_TIME    (50)
+
+#define REQ_SCAN                    (0)
+//#define REQ_SAVE_PROFILE          (BIT(0))
+#define REQ_DEL_PROFILE             (BIT(1))
+#define REQ_RENAME_DEV              (BIT(0) | BIT(1))
+#define REQ_ACK                     (BIT(2))
+
+#define RSP_CONFIG                  (BIT(5))
+#define RSP_SCAN                    (BIT(5) | BIT(0))
+//#define RSP_SAVE_PROFILE            (BIT(5) | BIT(1))
+#define RSP_DEL_PROFILE             (BIT(5) | BIT(1) | BIT(0))
+#define RSP_RENAME_DEV              (BIT(5) | BIT(2))
+
+#define RTK_SC_CONTROL_PKT_ROUND    100
+
+#define LOCAL_PORT_NUM              (8864)
+#define UNICAST_PORT_NUM            (8864)
+#define MCAST_PORT_NUM              (18864)
+
+#define MAC_ADDR_LEN                (6)
+#define MAX_INFO_LEN                (64)
+
+#define ACK_OFFSET_MAC              (3)
+#define ACK_OFFSET_STATUS           (9)
+#define ACK_OFFSET_DEV_TYPE         (10)
+#define ACK_OFFSET_IP               (12)
+#define ACK_OFFSET_DEV_NAME         (16)
+#define ACK_OFFSET_REQUIRE_PIN      (ACK_OFFSET_DEV_NAME+MAX_INFO_LEN)
+
+#define SC_USE_ENCRYPTION           1
+#define SC_NO_ENCRYPTION            PATTERN_USING_PLAIN
+
+#define SC_DBG_CONFIG_RECV          0
+
+struct dev_info{
+    unsigned char  status;                  //BIT(0):connected BIT(1):profile saved
+    unsigned short dev_type;
+    unsigned char  mac[MAC_ADDR_LEN];
+    unsigned int   ip;
+    unsigned char  extra_info[MAX_INFO_LEN];//name
+    unsigned char  require_pin;             //1-require PIN, 0-no need for PIN
+};
+
+typedef enum{
+    MODE_INIT = 0,
+    MODE_CONFIG,
+    MODE_WAIT_FOR_IP,
+    MODE_DISCOVER,
+    MODE_CONTROL,
+    MODE_ALERT,
+}PatternModes;
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/PatternBase.h

@@ -0,0 +1,55 @@
+//
+//  PatternBase.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/6.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#ifndef SimpleConfig_PatternBase_h
+#define SimpleConfig_PatternBase_h
+#import "Defines.h"
+#import "AsyncUdpSocket.h"
+#import "AsyncSocket.h"
+
+@interface PatternBase : NSObject <AsyncUdpSocketDelegate>
+{
+@public
+    NSString            *m_pattern_name;                        //pattern name
+    NSNumber            *m_pattern_flag;                        //pattern flag, indicating using encrpytion and else
+    
+    unsigned int        m_key_len;                              //length of AES Key
+    unsigned int        m_crypt_len;                            //length of crypted profile
+    unsigned int        m_plain_len;                            //length of plain profile
+    unsigned char       m_aes_key_buf[MAX_AES_KEY_LEN];         //store Key for AES
+    unsigned char       m_crypt_buf[MAX_BUF_LEN];               //store crytped profile
+    unsigned char       m_plain_buf[MAX_BUF_LEN];               //store plain profile
+    
+    unsigned char       m_security_level;                       //security level for control
+    
+    unsigned char       m_send_buf[MAX_BUF_LEN];                //data to send
+    
+    unsigned int        m_mode;                                 //current mode
+    NSString            *m_pin;                                 //PIN code if needed
+    NSMutableArray      *m_config_list;                         //clients list that sent config ack
+    AsyncUdpSocket      *m_configSocket;                        //socket
+    AsyncUdpSocket      *m_controlSocket;                       //socket(for ack)
+}
+
+// External APIs
+// initial
+- (id)      init: (unsigned int)pattern_flag;
+- (unsigned int)rtk_sc_get_mode;
+// simple config
+- (void)    rtk_pattern_set_dev_num: (int)device_num;
+- (int)     rtk_pattern_build_profile: (NSString *)ssid psw:(NSString *)password pin:(NSString *)pin;
+- (int)     rtk_pattern_send: (NSNumber *)times;
+- (int)     rtk_pattern_send_ack_packets;
+- (int)     rtk_pattern_send_ack_packets: (unsigned int) ip;
+- (void)    rtk_pattern_stop;
+- (void)    rtk_sc_close_sock;
+- (void)    rtk_sc_reopen_sock;
+- (NSMutableArray *)rtk_pattern_get_config_list;
+
+@end
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/PatternFour.h

@@ -0,0 +1,17 @@
+//
+//  PatternFour.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/20.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import "PatternBase.h"
+
+@interface PatternFour : PatternBase
+{
+@private
+    unsigned char m_rand[4];
+}
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/PatternThree.h

@@ -0,0 +1,18 @@
+//
+//  PatternThree.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/12.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#import "PatternBase.h"
+
+
+@interface PatternThree : PatternBase
+{
+@private
+    unsigned char m_rand[4];
+}
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/SimpleConfigLib/PatternTwo.h

@@ -0,0 +1,20 @@
+//
+//  PatternTwo.h
+//  SimpleConfig
+//
+//  Created by Realsil on 14/11/6.
+//  Copyright (c) 2014年 Realtek. All rights reserved.
+//
+
+#ifndef SimpleConfig_PatternTwo_h
+#define SimpleConfig_PatternTwo_h
+#import "PatternBase.h"
+
+@interface PatternTwo : PatternBase 
+{
+@private
+    unsigned char m_rand[4];
+}
+
+@end
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarCameraSimulator.h

@@ -0,0 +1,45 @@
+//------------------------------------------------------------------------
+//  Copyright 2010-2011 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+@class ZBarReaderView;
+
+// hack around missing simulator support for AVCapture interfaces
+
+@interface ZBarCameraSimulator
+    : NSObject
+    < UINavigationControllerDelegate,
+      UIImagePickerControllerDelegate,
+      UIPopoverControllerDelegate >
+{
+    UIViewController *viewController;
+    ZBarReaderView *readerView;
+    UIImagePickerController *picker;
+    UIPopoverController *pickerPopover;
+}
+
+- (id) initWithViewController: (UIViewController*) viewController;
+- (void) takePicture;
+
+@property (nonatomic, assign) ZBarReaderView *readerView;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarCaptureReader.h

@@ -0,0 +1,111 @@
+//------------------------------------------------------------------------
+//  Copyright 2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <CoreGraphics/CoreGraphics.h>
+#import "ZBarImageScanner.h"
+
+@class AVCaptureVideoDataOutput, AVCaptureOutput;
+@class ZBarCaptureReader, ZBarCVImage;
+
+@protocol ZBarCaptureDelegate <NSObject>
+
+// called when a new barcode is detected.  the image refers to the
+// video buffer and must not be retained for long
+- (void)       captureReader: (ZBarCaptureReader*) captureReader
+  didReadNewSymbolsFromImage: (ZBarImage*) image;
+
+@optional
+// called when a potential/uncertain barcode is detected.  will also
+// be called *after* captureReader:didReadNewSymbolsFromImage:
+// when good barcodes are detected
+- (void) captureReader: (ZBarCaptureReader*) captureReader
+       didTrackSymbols: (ZBarSymbolSet*) symbols;
+
+@end
+
+@interface ZBarCaptureReader
+    : NSObject
+{
+#if !TARGET_IPHONE_SIMULATOR
+    AVCaptureVideoDataOutput *captureOutput;
+    id<ZBarCaptureDelegate> captureDelegate;
+    ZBarImageScanner *scanner;
+    CGRect scanCrop;
+    CGSize size;
+    CGFloat framesPerSecond;
+    BOOL enableCache;
+
+    dispatch_queue_t queue;
+    ZBarImage *image;
+    ZBarCVImage *result;
+    volatile uint32_t state;
+    int framecnt;
+    unsigned width, height;
+    uint64_t t_frame, t_fps, t_scan;
+    CGFloat dt_frame;
+#endif
+}
+
+// supply a pre-configured image scanner
+- (id) initWithImageScanner: (ZBarImageScanner*) imageScanner;
+
+// this must be called before the session is started
+- (void) willStartRunning;
+
+// this must be called *before* the session is stopped
+- (void) willStopRunning;
+
+// clear the internal result cache
+- (void) flushCache;
+
+// capture the next frame after processing.  the captured image will
+// follow the same delegate path as an image with decoded symbols.
+- (void) captureFrame;
+
+// the capture output.  add this to an instance of AVCaptureSession
+@property (nonatomic, readonly) AVCaptureOutput *captureOutput;
+
+// delegate is notified of decode results and symbol tracking.
+@property (nonatomic, assign) id<ZBarCaptureDelegate> captureDelegate;
+
+// access to image scanner for configuration.
+@property (nonatomic, readonly) ZBarImageScanner *scanner;
+
+// region of image to scan in normalized coordinates.
+// NB horizontal crop currently ignored...
+@property (nonatomic, assign) CGRect scanCrop;
+
+// size of video frames.
+@property (nonatomic, readonly) CGSize size;
+
+// (quickly) gate the reader function without interrupting the video
+// stream.  also flushes the cache when enabled.  defaults to *NO*
+@property (nonatomic) BOOL enableReader;
+
+// current frame rate (for debug/optimization).
+// only valid when running
+@property (nonatomic, readonly) CGFloat framesPerSecond;
+
+@property (nonatomic) BOOL enableCache;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarHelpController.h

@@ -0,0 +1,60 @@
+//------------------------------------------------------------------------
+//  Copyright 2009-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <UIKit/UIKit.h>
+
+@class ZBarHelpController;
+
+@protocol ZBarHelpDelegate
+@optional
+
+- (void) helpControllerDidFinish: (ZBarHelpController*) help;
+
+@end
+
+
+// failure dialog w/a few useful tips
+
+@interface ZBarHelpController : UIViewController
+                              < UIWebViewDelegate,
+                                UIAlertViewDelegate >
+{
+    NSString *reason;
+    id delegate;
+    UIWebView *webView;
+    UIToolbar *toolbar;
+    UIBarButtonItem *doneBtn, *backBtn, *space;
+    NSURL *linkURL;
+    NSUInteger orientations;
+}
+
+@property (nonatomic, assign) id<ZBarHelpDelegate> delegate;
+
+// designated initializer
+- (id) initWithReason: (NSString*) reason;
+
+- (BOOL) isInterfaceOrientationSupported: (UIInterfaceOrientation) orientation;
+- (void) setInterfaceOrientation: (UIInterfaceOrientation) orientation
+                       supported: (BOOL) supported;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarImage.h

@@ -0,0 +1,69 @@
+//------------------------------------------------------------------------
+//  Copyright 2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <UIKit/UIKit.h>
+#import "zbar.h"
+#import "ZBarSymbol.h"
+
+#ifdef __cplusplus
+using namespace zbar;
+#endif
+
+// Obj-C wrapper for ZBar image
+
+@interface ZBarImage : NSObject
+{
+    zbar_image_t *zimg;
+    double t_convert;
+}
+
+@property (nonatomic) unsigned long format;
+@property (nonatomic) unsigned sequence;
+@property (nonatomic) CGSize size;
+@property (nonatomic) CGRect crop;
+@property (readonly, nonatomic) const void *data;
+@property (readonly, nonatomic) unsigned long dataLength;
+@property (copy, nonatomic) ZBarSymbolSet *symbols;
+@property (readonly, nonatomic) zbar_image_t *zbarImage;
+@property (readonly, nonatomic) UIImage *UIImage;
+
+- (id) initWithImage: (zbar_image_t*) image;
+- (id) initWithCGImage: (CGImageRef) image;
+- (id) initWithCGImage: (CGImageRef) image
+                  size: (CGSize) size;
+- (id) initWithCGImage: (CGImageRef) image
+                  crop: (CGRect) crop
+                  size: (CGSize) size;
+
+- (void) setData: (const void*) data
+      withLength: (unsigned long) length;
+- (UIImage*) UIImageWithOrientation: (UIImageOrientation) imageOrientation;
+- (void) cleanup;
+
++ (unsigned long) fourcc: (NSString*) format;
+
+#if 0
+- convertToFormat: (unsigned long) format;
+#endif
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarImageScanner.h

@@ -0,0 +1,51 @@
+//------------------------------------------------------------------------
+//  Copyright 2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <Foundation/Foundation.h>
+#import "zbar.h"
+#import "ZBarImage.h"
+
+#ifdef __cplusplus
+using namespace zbar;
+#endif
+
+// Obj-C wrapper for ZBar image scanner
+
+@interface ZBarImageScanner : NSObject
+{
+    zbar_image_scanner_t *scanner;
+}
+
+@property (nonatomic) BOOL enableCache;
+@property (readonly, nonatomic) ZBarSymbolSet *results;
+
+// decoder configuration
+- (void) parseConfig: (NSString*) configStr;
+- (void) setSymbology: (zbar_symbol_type_t) symbology
+               config: (zbar_config_t) config
+                   to: (int) value;
+
+// image scanning interface
+- (NSInteger) scanImage: (ZBarImage*) image;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarReaderController.h

@@ -0,0 +1,142 @@
+//------------------------------------------------------------------------
+//  Copyright 2009-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <UIKit/UIKit.h>
+#import "ZBarImageScanner.h"
+
+#ifdef __cplusplus
+using namespace zbar;
+#endif
+
+typedef enum {
+    // default interface provided by UIImagePickerController - user manually
+    // captures an image by pressing a button
+    ZBarReaderControllerCameraModeDefault = 0,
+
+    // automatically scan by taking screenshots with UIGetScreenImage().
+    // resolution is limited by the screen, so this is inappropriate for
+    // longer codes
+    ZBarReaderControllerCameraModeSampling,
+
+    // automatically scan by rapidly taking pictures with takePicture.
+    // tradeoff resolution with frame rate by adjusting the crop, and size
+    // properties of the reader along with the density configs of the image
+    // scanner
+    ZBarReaderControllerCameraModeSequence,
+
+} ZBarReaderControllerCameraMode;
+
+
+@class ZBarReaderController, ZBarHelpController;
+
+@protocol ZBarReaderDelegate <UIImagePickerControllerDelegate>
+@optional
+
+// called when no barcode is found in an image selected by the user.
+// if retry is NO, the delegate *must* dismiss the controller
+- (void) readerControllerDidFailToRead: (ZBarReaderController*) reader
+                             withRetry: (BOOL) retry;
+
+@end
+
+
+@interface ZBarReaderController
+    : UIImagePickerController
+    < UINavigationControllerDelegate,
+      UIImagePickerControllerDelegate >
+{
+    ZBarImageScanner *scanner;
+    ZBarHelpController *help;
+    UIView *overlay, *boxView;
+    CALayer *boxLayer;
+
+    UIToolbar *toolbar;
+    UIBarButtonItem *cancelBtn, *scanBtn, *space[3];
+    UIButton *infoBtn;
+
+    id <ZBarReaderDelegate> readerDelegate;
+    BOOL showsZBarControls, showsHelpOnFail, takesPicture, enableCache;
+    ZBarReaderControllerCameraMode cameraMode;
+    CGRect scanCrop;
+    NSInteger maxScanDimension;
+
+    BOOL hasOverlay, sampling;
+    uint64_t t_frame;
+    double dt_frame;
+
+    ZBarSymbol *symbol;
+}
+
+// access to configure image scanner
+@property (readonly, nonatomic) ZBarImageScanner *scanner;
+
+// barcode result recipient (NB don't use delegate)
+@property (nonatomic, assign) id <ZBarReaderDelegate> readerDelegate;
+
+// whether to use alternate control set
+@property (nonatomic) BOOL showsZBarControls;
+
+// whether to display helpful information when decoding fails
+@property (nonatomic) BOOL showsHelpOnFail;
+
+// how to use the camera (when sourceType == Camera)
+@property (nonatomic) ZBarReaderControllerCameraMode cameraMode;
+
+// whether to outline symbols with the green tracking box.
+@property (nonatomic) BOOL tracksSymbols;
+
+// whether to automatically take a full picture when a barcode is detected
+// (when cameraMode == Sampling)
+@property (nonatomic) BOOL takesPicture;
+
+// whether to use the "cache" for realtime modes (default YES).  this can be
+// used to safely disable the inter-frame consistency and duplicate checks,
+// speeding up recognition, iff:
+//     1. the controller is dismissed when a barcode is read and
+//     2. unreliable symbologies are disabled (all EAN/UPC variants and I2/5)
+@property (nonatomic) BOOL enableCache;
+
+// crop images for scanning.  the original image will be cropped to this
+// rectangle before scanning.  the rectangle is normalized to the image size
+// and aspect ratio; useful values will place the rectangle between 0 and 1
+// on each axis, where the x-axis corresponds to the image major axis.
+// defaults to the full image (0, 0, 1, 1).
+@property (nonatomic) CGRect scanCrop;
+
+// scale image to scan.  after cropping, the image will be scaled if
+// necessary, such that neither of its dimensions exceed this value.
+// defaults to 640.
+@property (nonatomic) NSInteger maxScanDimension;
+
+// display the built-in help browser.  for use with custom overlays if
+// you don't also want to create your own help view.  only send this
+// message when the reader is displayed.  the argument will be passed
+// to the onZBarHelp() javascript function.
+- (void) showHelpWithReason: (NSString*) reason;
+
+// direct scanner interface - scan UIImage and return something enumerable
+- (id <NSFastEnumeration>) scanImage: (CGImageRef) image;
+
+@end
+
+extern NSString* const ZBarReaderControllerResults;

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarReaderView.h

@@ -0,0 +1,135 @@
+//------------------------------------------------------------------------
+//  Copyright 2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <UIKit/UIKit.h>
+#import "ZBarImageScanner.h"
+
+@class AVCaptureSession, AVCaptureDevice;
+@class CALayer;
+@class ZBarImageScanner, ZBarCaptureReader, ZBarReaderView;
+
+// delegate is notified of decode results.
+
+@protocol ZBarReaderViewDelegate < NSObject >
+
+- (void) readerView: (ZBarReaderView*) readerView
+     didReadSymbols: (ZBarSymbolSet*) symbols
+          fromImage: (UIImage*) image;
+
+@end
+
+// read barcodes from the displayed video preview.  the view maintains
+// a complete video capture session feeding a ZBarCaptureReader and
+// presents the associated preview with symbol tracking annotations.
+
+@interface ZBarReaderView
+    : UIView
+{
+    id<ZBarReaderViewDelegate> readerDelegate;
+    ZBarCaptureReader *captureReader;
+    CGRect scanCrop, effectiveCrop;
+    CGAffineTransform previewTransform;
+    CGFloat zoom, zoom0, maxZoom;
+    UIColor *trackingColor;
+    BOOL tracksSymbols, showsFPS;
+    NSInteger torchMode;
+    UIInterfaceOrientation interfaceOrientation;
+    NSTimeInterval animationDuration;
+
+    CALayer *preview, *overlay, *tracking, *cropLayer;
+    UIView *fpsView;
+    UILabel *fpsLabel;
+    UIPinchGestureRecognizer *pinch;
+    CGFloat imageScale;
+    CGSize imageSize;
+    BOOL started, running;
+}
+
+// supply a pre-configured image scanner.
+- (id) initWithImageScanner: (ZBarImageScanner*) imageScanner;
+
+// start the video stream and barcode reader.
+- (void) start;
+
+// stop the video stream and barcode reader.
+- (void) stop;
+
+// clear the internal result cache
+- (void) flushCache;
+
+// compensate for device/camera/interface orientation
+- (void) willRotateToInterfaceOrientation: (UIInterfaceOrientation) orient
+                                 duration: (NSTimeInterval) duration;
+
+// delegate is notified of decode results.
+@property (nonatomic, assign) id<ZBarReaderViewDelegate> readerDelegate;
+
+// access to image scanner for configuration.
+@property (nonatomic, readonly) ZBarImageScanner *scanner;
+
+// whether to display the tracking annotation for uncertain barcodes
+// (default YES).
+@property (nonatomic) BOOL tracksSymbols;
+
+// color of the tracking box (default green)
+@property (nonatomic, retain) UIColor *trackingColor;
+
+// enable pinch gesture recognition for zooming the preview/decode
+// (default YES).
+@property (nonatomic) BOOL allowsPinchZoom;
+
+// torch mode to set automatically (default Auto).
+@property (nonatomic) NSInteger torchMode;
+
+// whether to display the frame rate for debug/configuration
+// (default NO).
+@property (nonatomic) BOOL showsFPS;
+
+// zoom scale factor applied to video preview *and* scanCrop.
+// also updated by pinch-zoom gesture.  clipped to range [1,maxZoom],
+// defaults to 1.25
+@property (nonatomic) CGFloat zoom;
+- (void) setZoom: (CGFloat) zoom
+        animated: (BOOL) animated;
+
+// maximum settable zoom factor.
+@property (nonatomic) CGFloat maxZoom;
+
+// the region of the image that will be scanned.  normalized coordinates.
+@property (nonatomic) CGRect scanCrop;
+
+// additional transform applied to video preview.
+// (NB *not* applied to scan crop)
+@property (nonatomic) CGAffineTransform previewTransform;
+
+// specify an alternate capture device.
+@property (nonatomic, retain) AVCaptureDevice *device;
+
+// direct access to the capture session.  warranty void if opened...
+@property (nonatomic, readonly) AVCaptureSession *session;
+@property (nonatomic, readonly) ZBarCaptureReader *captureReader;
+
+// this flag still works, but its use is deprecated
+@property (nonatomic) BOOL enableCache;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarReaderViewController.h

@@ -0,0 +1,130 @@
+//------------------------------------------------------------------------
+//  Copyright 2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <UIKit/UIKit.h>
+#import "ZBarReaderController.h"
+
+// orientation set support
+#define ZBarOrientationMask(orient) (1 << orient)
+#define ZBarOrientationMaskAll \
+    (ZBarOrientationMask(UIInterfaceOrientationPortrait) | \
+     ZBarOrientationMask(UIInterfaceOrientationPortraitUpsideDown) | \
+     ZBarOrientationMask(UIInterfaceOrientationLandscapeLeft) | \
+     ZBarOrientationMask(UIInterfaceOrientationLandscapeRight))
+
+@class ZBarReaderView, ZBarCameraSimulator;
+
+// drop in video scanning replacement for ZBarReaderController.
+// this is a thin controller around a ZBarReaderView that adds the UI
+// controls and select functionality offered by ZBarReaderController.
+// Automatically falls back to a ZBarReaderController if video APIs
+// are unavailable (eg for OS < 4.0)
+
+@interface ZBarReaderViewController
+    : UIViewController
+{
+    ZBarImageScanner *scanner;
+    id <ZBarReaderDelegate> readerDelegate;
+    ZBarReaderView *readerView;
+    UIView *cameraOverlayView;
+    CGAffineTransform cameraViewTransform;
+    CGRect scanCrop;
+    NSUInteger supportedOrientationsMask;
+    UIImagePickerControllerCameraDevice cameraDevice;
+    UIImagePickerControllerCameraFlashMode cameraFlashMode;
+    UIImagePickerControllerQualityType videoQuality;
+    BOOL showsZBarControls, tracksSymbols, enableCache;
+
+    ZBarHelpController *helpController;
+    UIView *controls;
+    BOOL didHideStatusBar, rotating;
+    ZBarCameraSimulator *cameraSim;
+}
+
+// access to configure image scanner
+@property (nonatomic, readonly) ZBarImageScanner *scanner;
+
+// barcode result recipient
+@property (nonatomic, assign) id <ZBarReaderDelegate> readerDelegate;
+
+// whether to use alternate control set
+@property (nonatomic) BOOL showsZBarControls;
+
+// whether to show the green tracking box.  note that, even when
+// enabled, the box will only be visible when scanning EAN and I2/5.
+@property (nonatomic) BOOL tracksSymbols;
+
+// interface orientation support.  bit-mask of accepted orientations.
+// see eg ZBarOrientationMask() and ZBarOrientationMaskAll
+@property (nonatomic) NSUInteger supportedOrientationsMask;
+
+// crop images for scanning.  the image will be cropped to this
+// rectangle before scanning.  the rectangle is normalized to the
+// image size and aspect ratio; useful values will place the rectangle
+// between 0 and 1 on each axis, where the x-axis corresponds to the
+// image major axis.  defaults to the full image (0, 0, 1, 1).
+@property (nonatomic) CGRect scanCrop;
+
+// provide a custom overlay.  note that this can be used with
+// showsZBarControls enabled (but not if you want backward compatibility)
+@property (nonatomic, retain) UIView *cameraOverlayView;
+
+// transform applied to the preview image.
+@property (nonatomic) CGAffineTransform cameraViewTransform;
+
+// display the built-in help browser.  the argument will be passed to
+// the onZBarHelp() javascript function.
+- (void) showHelpWithReason: (NSString*) reason;
+
+// capture the next frame and send it over the usual delegate path.
+- (void) takePicture;
+
+// these attempt to emulate UIImagePickerController
++ (BOOL) isCameraDeviceAvailable: (UIImagePickerControllerCameraDevice) cameraDevice;
++ (BOOL) isFlashAvailableForCameraDevice: (UIImagePickerControllerCameraDevice) cameraDevice;
++ (NSArray*) availableCaptureModesForCameraDevice: (UIImagePickerControllerCameraDevice) cameraDevice;
+@property(nonatomic) UIImagePickerControllerCameraDevice cameraDevice;
+@property(nonatomic) UIImagePickerControllerCameraFlashMode cameraFlashMode;
+@property(nonatomic) UIImagePickerControllerCameraCaptureMode cameraCaptureMode;
+@property(nonatomic) UIImagePickerControllerQualityType videoQuality;
+
+// direct access to the ZBarReaderView
+@property (nonatomic, readonly) ZBarReaderView *readerView;
+
+// this flag still works, but its use is deprecated
+@property (nonatomic) BOOL enableCache;
+
+// these are present only for backward compatibility.
+// they will error if inappropriate/unsupported values are set
+@property (nonatomic) UIImagePickerControllerSourceType sourceType; // Camera
+@property (nonatomic) BOOL allowsEditing; // NO
+@property (nonatomic) BOOL allowsImageEditing; // NO
+@property (nonatomic) BOOL showsCameraControls; // NO
+@property (nonatomic) BOOL showsHelpOnFail; // ignored
+@property (nonatomic) ZBarReaderControllerCameraMode cameraMode; // Sampling
+@property (nonatomic) BOOL takesPicture; // NO
+@property (nonatomic) NSInteger maxScanDimension; // ignored
+
++ (BOOL) isSourceTypeAvailable: (UIImagePickerControllerSourceType) sourceType;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarSDK.h

@@ -0,0 +1,34 @@
+/*------------------------------------------------------------------------
+ *  Copyright 2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+ *
+ *  This file is part of the ZBar Bar Code Reader.
+ *
+ *  The ZBar Bar Code Reader is free software; you can redistribute it
+ *  and/or modify it under the terms of the GNU Lesser Public License as
+ *  published by the Free Software Foundation; either version 2.1 of
+ *  the License, or (at your option) any later version.
+ *
+ *  The ZBar Bar Code Reader is distributed in the hope that it will be
+ *  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+ *  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU Lesser Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser Public License
+ *  along with the ZBar Bar Code Reader; if not, write to the Free
+ *  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+ *  Boston, MA  02110-1301  USA
+ *
+ *  http://sourceforge.net/projects/zbar
+ *------------------------------------------------------------------------*/
+
+#import "zbar.h"
+
+#import "ZBarSymbol.h"
+#import "ZBarImage.h"
+#import "ZBarImageScanner.h"
+#import "ZBarReaderView.h"
+#import "ZBarReaderViewController.h"
+#import "ZBarReaderController.h"
+#import "ZBarCaptureReader.h"
+#import "ZBarHelpController.h"
+#import "ZBarCameraSimulator.h"

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/ZBarSymbol.h

@@ -0,0 +1,71 @@
+//------------------------------------------------------------------------
+//  Copyright 2009-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+
+#import <Foundation/Foundation.h>
+#import <CoreGraphics/CoreGraphics.h>
+#import "zbar.h"
+
+#ifdef __cplusplus
+using namespace zbar;
+#endif
+
+// Obj-C wrapper for ZBar result types
+
+@interface ZBarSymbolSet
+    : NSObject <NSFastEnumeration>
+{
+    const zbar_symbol_set_t *set;
+    BOOL filterSymbols;
+}
+
+@property (readonly, nonatomic) int count;
+@property (readonly, nonatomic) const zbar_symbol_set_t *zbarSymbolSet;
+@property (nonatomic) BOOL filterSymbols;
+
+- (id) initWithSymbolSet: (const zbar_symbol_set_t*) set;
+
+@end
+
+
+@interface ZBarSymbol : NSObject
+{
+    const zbar_symbol_t *symbol;
+}
+
+@property (readonly, nonatomic) zbar_symbol_type_t type;
+@property (readonly, nonatomic) NSString *typeName;
+@property (readonly, nonatomic) NSUInteger configMask;
+@property (readonly, nonatomic) NSUInteger modifierMask;
+@property (readonly, nonatomic) NSString *data;
+@property (readonly, nonatomic) int quality;
+@property (readonly, nonatomic) int count;
+@property (readonly, nonatomic) zbar_orientation_t orientation;
+@property (readonly, nonatomic) ZBarSymbolSet *components;
+@property (readonly, nonatomic) const zbar_symbol_t *zbarSymbol;
+@property (readonly, nonatomic) CGRect bounds;
+
+- (id) initWithSymbol: (const zbar_symbol_t*) symbol;
+
++ (NSString*) nameForType: (zbar_symbol_type_t) type;
+
+@end

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Decoder.h

@@ -0,0 +1,202 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_DECODER_H_
+#define _ZBAR_DECODER_H_
+
+/// @file
+/// Decoder C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Decoder.h"
+#endif
+
+#include <string>
+
+namespace zbar {
+
+/// low-level bar width stream decoder interface.
+/// identifies symbols and extracts encoded data
+
+class Decoder {
+ public:
+
+    /// Decoder result handler.
+    /// applications should subtype this and pass an instance to
+    /// set_handler() to implement result processing
+    class Handler {
+    public:
+        virtual ~Handler() { }
+
+        /// invoked by the Decoder as decode results become available.
+        virtual void decode_callback(Decoder &decoder) = 0;
+    };
+
+    /// constructor.
+    Decoder ()
+        : _handler(NULL)
+    {
+        _decoder = zbar_decoder_create();
+    }
+
+    ~Decoder ()
+    {
+        zbar_decoder_destroy(_decoder);
+    }
+
+    /// clear all decoder state.
+    /// see zbar_decoder_reset()
+    void reset ()
+    {
+        zbar_decoder_reset(_decoder);
+    }
+
+    /// mark start of a new scan pass.
+    /// see zbar_decoder_new_scan()
+    void new_scan ()
+    {
+        zbar_decoder_new_scan(_decoder);
+    }
+
+    /// process next bar/space width from input stream.
+    /// see zbar_decode_width()
+    zbar_symbol_type_t decode_width (unsigned width)
+    {
+        return(zbar_decode_width(_decoder, width));
+    }
+
+    /// process next bar/space width from input stream.
+    /// see zbar_decode_width()
+    Decoder& operator<< (unsigned width)
+    {
+        zbar_decode_width(_decoder, width);
+        return(*this);
+    }
+
+    /// retrieve color of @em next element passed to Decoder.
+    /// see zbar_decoder_get_color()
+    zbar_color_t get_color () const
+    {
+        return(zbar_decoder_get_color(_decoder));
+    }
+
+    /// retrieve last decoded symbol type.
+    /// see zbar_decoder_get_type()
+    zbar_symbol_type_t get_type () const
+    {
+        return(zbar_decoder_get_type(_decoder));
+    }
+
+    /// retrieve string name of last decoded symbol type.
+    /// see zbar_get_symbol_name()
+    const char *get_symbol_name () const
+    {
+        return(zbar_get_symbol_name(zbar_decoder_get_type(_decoder)));
+    }
+
+    /// retrieve string name for last decode addon.
+    /// see zbar_get_addon_name()
+    /// @deprecated in 0.11
+    const char *get_addon_name () const
+    {
+        return(zbar_get_addon_name(zbar_decoder_get_type(_decoder)));
+    }
+
+    /// retrieve last decoded data in ASCII format as a char array.
+    /// see zbar_decoder_get_data()
+    const char *get_data_chars() const
+    {
+        return(zbar_decoder_get_data(_decoder));
+    }
+
+    /// retrieve last decoded data as a std::string.
+    /// see zbar_decoder_get_data()
+    const std::string get_data_string() const
+    {
+        return(std::string(zbar_decoder_get_data(_decoder),
+                           zbar_decoder_get_data_length(_decoder)));
+    }
+
+    /// retrieve last decoded data as a std::string.
+    /// see zbar_decoder_get_data()
+    const std::string get_data() const
+    {
+        return(get_data_string());
+    }
+
+    /// retrieve length of decoded binary data.
+    /// see zbar_decoder_get_data_length()
+    int get_data_length() const
+    {
+        return(zbar_decoder_get_data_length(_decoder));
+    }
+
+    /// retrieve last decode direction.
+    /// see zbar_decoder_get_direction()
+    /// @since 0.11
+    int get_direction() const
+    {
+        return(zbar_decoder_get_direction(_decoder));
+    }
+
+    /// setup callback to handle result data.
+    void set_handler (Handler &handler)
+    {
+        _handler = &handler;
+        zbar_decoder_set_handler(_decoder, _cb);
+        zbar_decoder_set_userdata(_decoder, this);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_decoder_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_decoder_set_config(_decoder, symbology, config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_decoder_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_decoder_parse_config(_decoder, cfgstr.c_str()));
+    }
+
+ private:
+    friend class Scanner;
+    zbar_decoder_t *_decoder;
+    Handler *_handler;
+
+    static void _cb (zbar_decoder_t *cdcode)
+    {
+        Decoder *dcode = (Decoder*)zbar_decoder_get_userdata(cdcode);
+        if(dcode && dcode->_handler)
+            dcode->_handler->decode_callback(*dcode);
+    }
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Exception.h

@@ -0,0 +1,187 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_EXCEPTION_H_
+#define _ZBAR_EXCEPTION_H_
+
+/// @file
+/// C++ Exception definitions
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Exception.h"
+#endif
+
+#include <exception>
+#include <new>
+
+namespace zbar {
+
+/// base class for exceptions defined by this API.
+class Exception : public std::exception {
+
+public:
+    /// create exception from C library error
+    Exception (const void *obj = NULL)
+        : std::exception(),
+          _obj(obj)
+    { }
+
+    ~Exception () throw() { }
+
+    /// retrieve error message
+    virtual const char* what () const throw()
+    {
+        if(!_obj)
+            return("zbar library unspecified generic error");
+        return(_zbar_error_string(_obj, 0));
+    }
+
+private:
+    const void *_obj;
+};
+
+/// internal library error.
+class InternalError : public Exception {
+public:
+    /// create exception from C library error
+    InternalError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// unsupported request.
+class UnsupportedError : public Exception {
+public:
+    /// create exception from C library error
+    UnsupportedError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// invalid request.
+class InvalidError : public Exception {
+public:
+    /// create exception from C library error
+    InvalidError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// failed system call.
+class SystemError : public Exception {
+public:
+    /// create exception from C library error
+    SystemError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// locking error.
+class LockingError : public Exception {
+public:
+    /// create exception from C library error
+    LockingError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// all resources busy.
+class BusyError : public Exception {
+public:
+    /// create exception from C library error
+    BusyError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// X11 display error.
+class XDisplayError : public Exception {
+public:
+    /// create exception from C library error
+    XDisplayError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// X11 protocol error.
+class XProtoError : public Exception {
+public:
+    /// create exception from C library error
+    XProtoError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// output window is closed.
+class ClosedError : public Exception {
+public:
+    /// create exception from C library error
+    ClosedError (const void *obj)
+        : Exception(obj)
+    { }
+};
+
+/// image format error
+class FormatError : public Exception {
+    // FIXME needs c equivalent
+
+    virtual const char* what () const throw()
+    {
+        // FIXME what format?
+        return("unsupported format");
+    }
+};
+
+/// @internal
+
+/// extract error information and create exception.
+static inline std::exception throw_exception (const void *obj)
+{
+    switch(_zbar_get_error_code(obj)) {
+    case ZBAR_ERR_NOMEM:
+        throw std::bad_alloc();
+    case ZBAR_ERR_INTERNAL:
+        throw InternalError(obj);
+    case ZBAR_ERR_UNSUPPORTED:
+        throw UnsupportedError(obj);
+    case ZBAR_ERR_INVALID:
+        throw InvalidError(obj);
+    case ZBAR_ERR_SYSTEM:
+        throw SystemError(obj);
+    case ZBAR_ERR_LOCKING:
+        throw LockingError(obj);
+    case ZBAR_ERR_BUSY:
+        throw BusyError(obj);
+    case ZBAR_ERR_XDISPLAY:
+        throw XDisplayError(obj);
+    case ZBAR_ERR_XPROTO:
+        throw XProtoError(obj);
+    case ZBAR_ERR_CLOSED:
+        throw ClosedError(obj);
+    default:
+        throw Exception(obj);
+    }
+}
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Image.h

@@ -0,0 +1,321 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_IMAGE_H_
+#define _ZBAR_IMAGE_H_
+
+/// @file
+/// Image C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Image.h"
+#endif
+
+#include <assert.h>
+#include <iterator>
+#include "Symbol.h"
+#include "Exception.h"
+
+namespace zbar {
+
+class Video;
+
+/// stores image data samples along with associated format and size
+/// metadata
+
+class Image {
+public:
+
+    /// general Image result handler.
+    /// applications should subtype this and pass an instance to
+    /// eg. ImageScanner::set_handler() to implement result processing
+    class Handler {
+    public:
+        virtual ~Handler() { }
+
+        /// invoked by library when Image should be processed
+        virtual void image_callback(Image &image) = 0;
+
+        /// cast this handler to the C handler
+        operator zbar_image_data_handler_t* () const
+        {
+            return(_cb);
+        }
+
+    private:
+        static void _cb (zbar_image_t *zimg,
+                         const void *userdata)
+        {
+            if(userdata) {
+                Image *image = (Image*)zbar_image_get_userdata(zimg);
+                if(image)
+                    ((Handler*)userdata)->image_callback(*image);
+                else {
+                    Image tmp(zimg, 1);
+                    ((Handler*)userdata)->image_callback(tmp);
+                }
+            }
+        }
+    };
+
+    class SymbolIterator : public zbar::SymbolIterator {
+    public:
+        /// default constructor.
+        SymbolIterator ()
+            : zbar::SymbolIterator()
+        { }
+
+        /// constructor.
+        SymbolIterator (const SymbolSet &syms)
+            : zbar::SymbolIterator(syms)
+        { }
+
+        /// copy constructor.
+        SymbolIterator (const SymbolIterator& iter)
+            : zbar::SymbolIterator(iter)
+        { }
+    };
+
+    /// constructor.
+    /// create a new Image with the specified parameters
+    Image (unsigned width = 0,
+           unsigned height = 0,
+           const std::string& format = "",
+           const void *data = NULL,
+           unsigned long length = 0)
+        : _img(zbar_image_create())
+    {
+        zbar_image_set_userdata(_img, this);
+        if(width && height)
+            set_size(width, height);
+        if(format.length())
+            set_format(format);
+        if(data && length)
+            set_data(data, length);
+    }
+
+    ~Image ()
+    {
+        set_data(NULL, 0);
+        zbar_image_set_userdata(_img, NULL);
+        zbar_image_ref(_img, -1);
+    }
+
+    /// cast to C image object
+    operator const zbar_image_t* () const
+    {
+        return(_img);
+    }
+
+    /// cast to C image object
+    operator zbar_image_t* ()
+    {
+        return(_img);
+    }
+
+    /// retrieve the image format.
+    /// see zbar_image_get_format()
+    unsigned long get_format () const
+    {
+        return(zbar_image_get_format(_img));
+    }
+
+    /// specify the fourcc image format code for image sample data.
+    /// see zbar_image_set_format()
+    void set_format (unsigned long format)
+    {
+        zbar_image_set_format(_img, format);
+    }
+
+    /// specify the fourcc image format code for image sample data.
+    /// see zbar_image_set_format()
+    void set_format (const std::string& format)
+    {
+        unsigned long fourcc = zbar_fourcc_parse(format.c_str());
+        zbar_image_set_format(_img, fourcc);
+    }
+
+    /// retrieve a "sequence" (page/frame) number associated with this
+    /// image.
+    /// see zbar_image_get_sequence()
+    /// @since 0.6
+    unsigned get_sequence () const
+    {
+        return(zbar_image_get_sequence(_img));
+    }
+
+    /// associate a "sequence" (page/frame) number with this image.
+    /// see zbar_image_set_sequence()
+    /// @since 0.6
+    void set_sequence (unsigned sequence_num)
+    {
+        zbar_image_set_sequence(_img, sequence_num);
+    }
+
+    /// retrieve the width of the image.
+    /// see zbar_image_get_width()
+    unsigned get_width () const
+    {
+        return(zbar_image_get_width(_img));
+    }
+
+    /// retrieve the height of the image.
+    /// see zbar_image_get_height()
+    unsigned get_height () const
+    {
+        return(zbar_image_get_height(_img));
+    }
+
+    /// retrieve both dimensions of the image.
+    /// see zbar_image_get_size()
+    /// @since 0.11
+    void get_size (unsigned &width,
+                   unsigned &height) const
+    {
+        zbar_image_get_size(_img, &width, &height);
+    }
+
+    /// specify the pixel size of the image.
+    /// see zbar_image_set_size()
+    void set_size (unsigned width,
+                   unsigned height)
+    {
+        zbar_image_set_size(_img, width, height);
+    }
+
+    /// retrieve the scan crop rectangle.
+    /// see zbar_image_get_crop()
+    void get_crop (unsigned &x,
+                   unsigned &y,
+                   unsigned &width,
+                   unsigned &height) const
+    {
+        zbar_image_get_crop(_img, &x, &y, &width, &height);
+    }
+
+    /// set the scan crop rectangle.
+    /// see zbar_image_set_crop()
+    void set_crop (unsigned x,
+                   unsigned y,
+                   unsigned width,
+                   unsigned height)
+    {
+        zbar_image_set_crop(_img, x, y, width, height);
+    }
+
+    /// return the image sample data.
+    /// see zbar_image_get_data()
+    const void *get_data () const
+    {
+        return(zbar_image_get_data(_img));
+    }
+
+    /// return the size of the image sample data.
+    /// see zbar_image_get_data_length()
+    /// @since 0.6
+    unsigned long get_data_length () const
+    {
+        return(zbar_image_get_data_length(_img));
+    }
+
+    /// specify image sample data.
+    /// see zbar_image_set_data()
+    void set_data (const void *data,
+                   unsigned long length)
+    {
+        zbar_image_set_data(_img, data, length, _cleanup);
+    }
+
+    /// image format conversion.
+    /// see zbar_image_convert()
+    Image convert (unsigned long format) const
+    {
+        zbar_image_t *img = zbar_image_convert(_img, format);
+        if(img)
+            return(Image(img));
+        throw FormatError();
+    }
+
+    /// image format conversion with crop/pad.
+    /// see zbar_image_convert_resize()
+    /// @since 0.4
+    Image convert (unsigned long format,
+                   unsigned width,
+                   unsigned height) const
+    {
+        zbar_image_t *img =
+            zbar_image_convert_resize(_img, format, width, height);
+        if(img)
+            return(Image(img));
+        throw FormatError();
+    }
+
+    const SymbolSet get_symbols () const {
+        return(SymbolSet(zbar_image_get_symbols(_img)));
+    }
+
+    void set_symbols (const SymbolSet &syms) {
+        zbar_image_set_symbols(_img, syms);
+    }
+
+    /// create a new SymbolIterator over decoded results.
+    SymbolIterator symbol_begin () const {
+        return(SymbolIterator(get_symbols()));
+    }
+
+    /// return a SymbolIterator suitable for ending iteration.
+    SymbolIterator symbol_end () const {
+        return(SymbolIterator());
+    }
+
+protected:
+
+    friend class Video;
+
+    /// constructor.
+    /// @internal
+    /// create a new Image from a zbar_image_t C object
+    Image (zbar_image_t *src,
+           int refs = 0)
+        : _img(src)
+    {
+        if(refs)
+            zbar_image_ref(_img, refs);
+        zbar_image_set_userdata(_img, this);
+    }
+
+    /// default data cleanup (noop)
+    /// @internal
+    static void _cleanup (zbar_image_t *img)
+    {
+        // by default nothing is cleaned
+        assert(img);
+        assert(zbar_image_get_userdata(img));
+    }
+
+private:
+    zbar_image_t *_img;
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/ImageScanner.h

@@ -0,0 +1,130 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_IMAGE_SCANNER_H_
+#define _ZBAR_IMAGE_SCANNER_H_
+
+/// @file
+/// Image Scanner C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/ImageScanner.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level image scanner interface.
+/// reads barcodes from a 2-D Image
+
+class ImageScanner {
+public:
+    /// constructor.
+    ImageScanner (zbar_image_scanner_t *scanner = NULL)
+    {
+        if(scanner)
+            _scanner = scanner;
+        else
+            _scanner = zbar_image_scanner_create();
+    }
+
+    ~ImageScanner ()
+    {
+        zbar_image_scanner_destroy(_scanner);
+    }
+
+    /// cast to C image_scanner object
+    operator zbar_image_scanner_t* () const
+    {
+        return(_scanner);
+    }
+
+    /// setup result handler callback.
+    void set_handler (Image::Handler &handler)
+    {
+        zbar_image_scanner_set_data_handler(_scanner, handler, &handler);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_image_scanner_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_image_scanner_set_config(_scanner, symbology,
+                                              config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_image_scanner_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_image_scanner_parse_config(_scanner, cfgstr.c_str()));
+    }
+
+    /// enable or disable the inter-image result cache.
+    /// see zbar_image_scanner_enable_cache()
+    void enable_cache (bool enable = true)
+    {
+        zbar_image_scanner_enable_cache(_scanner, enable);
+    }
+
+    /// remove previous results from scanner and image.
+    /// @see zbar_image_scanner_recycle_image()
+    /// @since 0.10
+    void recycle_image (Image &image)
+    {
+        zbar_image_scanner_recycle_image(_scanner, image);
+    }
+
+    /// retrieve decode results for last scanned image.
+    /// @see zbar_image_scanner_get_results()
+    /// @since 0.10
+    const SymbolSet get_results () const {
+        return(SymbolSet(zbar_image_scanner_get_results(_scanner)));
+    }
+
+    /// scan for symbols in provided image.
+    /// see zbar_scan_image()
+    int scan (Image& image)
+    {
+        return(zbar_scan_image(_scanner, image));
+    }
+
+    /// scan for symbols in provided image.
+    /// see zbar_scan_image()
+    ImageScanner& operator<< (Image& image)
+    {
+        scan(image);
+        return(*this);
+    }
+
+private:
+    zbar_image_scanner_t *_scanner;
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Processor.h

@@ -0,0 +1,223 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_PROCESSOR_H_
+#define _ZBAR_PROCESSOR_H_
+
+/// @file
+/// Processor C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Processor.h"
+#endif
+
+#include "Exception.h"
+#include "Image.h"
+
+namespace zbar {
+
+/// high-level self-contained image processor.
+/// processes video and images for barcodes, optionally displaying
+/// images to a library owned output window
+
+class Processor {
+ public:
+    /// value to pass for no timeout.
+    static const int FOREVER = -1;
+
+    /// constructor.
+    Processor (bool threaded = true,
+               const char *video_device = "",
+               bool enable_display = true)
+    {
+        _processor = zbar_processor_create(threaded);
+        if(!_processor)
+            throw std::bad_alloc();
+        init(video_device, enable_display);
+    }
+
+    ~Processor ()
+    {
+        zbar_processor_destroy(_processor);
+    }
+
+    /// cast to C processor object.
+    operator zbar_processor_t* ()
+    {
+        return(_processor);
+    }
+
+    /// opens a video input device and/or prepares to display output.
+    /// see zbar_processor_init()
+    void init (const char *video_device = "",
+               bool enable_display = true)
+    {
+        if(zbar_processor_init(_processor, video_device, enable_display))
+            throw_exception(_processor);
+    }
+
+    /// setup result handler callback.
+    /// see zbar_processor_set_data_handler()
+    void set_handler (Image::Handler& handler)
+    {
+        zbar_processor_set_data_handler(_processor, handler, &handler);
+    }
+
+    /// set config for indicated symbology (0 for all) to specified value.
+    /// @see zbar_processor_set_config()
+    /// @since 0.4
+    int set_config (zbar_symbol_type_t symbology,
+                    zbar_config_t config,
+                    int value)
+    {
+        return(zbar_processor_set_config(_processor, symbology,
+                                          config, value));
+    }
+
+    /// set config parsed from configuration string.
+    /// @see zbar_processor_parse_config()
+    /// @since 0.4
+    int set_config (std::string cfgstr)
+    {
+        return(zbar_processor_parse_config(_processor, cfgstr.c_str()));
+    }
+
+    /// retrieve the current state of the ouput window.
+    /// see zbar_processor_is_visible()
+    bool is_visible ()
+    {
+        int rc = zbar_processor_is_visible(_processor);
+        if(rc < 0)
+            throw_exception(_processor);
+        return(rc != 0);
+    }
+
+    /// show or hide the display window owned by the library.
+    /// see zbar_processor_set_visible()
+    void set_visible (bool visible = true)
+    {
+        if(zbar_processor_set_visible(_processor, visible) < 0)
+            throw_exception(_processor);
+    }
+
+    /// control the processor in free running video mode.
+    /// see zbar_processor_set_active()
+    void set_active (bool active = true)
+    {
+        if(zbar_processor_set_active(_processor, active) < 0)
+            throw_exception(_processor);
+    }
+
+    /// retrieve decode results for last scanned image.
+    /// @see zbar_processor_get_results()
+    /// @since 0.10
+    const SymbolSet get_results () const {
+        return(SymbolSet(zbar_processor_get_results(_processor)));
+    }
+
+    /// wait for input to the display window from the user.
+    /// see zbar_processor_user_wait()
+    int user_wait (int timeout = FOREVER)
+    {
+        int rc = zbar_processor_user_wait(_processor, timeout);
+        if(rc < 0)
+            throw_exception(_processor);
+        return(rc);
+    }
+
+    /// process from the video stream until a result is available.
+    /// see zbar_process_one()
+    void process_one (int timeout = FOREVER)
+    {
+        if(zbar_process_one(_processor, timeout) < 0)
+            throw_exception(_processor);
+    }
+
+    /// process the provided image for barcodes.
+    /// see zbar_process_image()
+    void process_image (Image& image)
+    {
+        if(zbar_process_image(_processor, image) < 0)
+            throw_exception(_processor);
+    }
+
+    /// process the provided image for barcodes.
+    /// see zbar_process_image()
+    Processor& operator<< (Image& image)
+    {
+        process_image(image);
+        return(*this);
+    }
+
+    /// force specific input and output formats for debug/testing.
+    /// see zbar_processor_force_format()
+    void force_format (unsigned long input_format,
+                       unsigned long output_format)
+    {
+        if(zbar_processor_force_format(_processor, input_format,
+                                        output_format))
+            throw_exception(_processor);
+    }
+
+    /// force specific input and output formats for debug/testing.
+    /// see zbar_processor_force_format()
+    void force_format (std::string& input_format,
+                       std::string& output_format)
+    {
+        unsigned long ifourcc = zbar_fourcc_parse(input_format.c_str());
+        unsigned long ofourcc = zbar_fourcc_parse(output_format.c_str());
+        if(zbar_processor_force_format(_processor, ifourcc, ofourcc))
+            throw_exception(_processor);
+    }
+
+    /// request a preferred size for the video image from the device.
+    /// see zbar_processor_request_size()
+    /// @since 0.6
+    void request_size (int width, int height)
+    {
+        zbar_processor_request_size(_processor, width, height);
+    }
+
+    /// request a preferred driver interface version for debug/testing.
+    /// see zbar_processor_request_interface()
+    /// @since 0.6
+    void request_interface (int version)
+    {
+        zbar_processor_request_interface(_processor, version);
+    }
+
+    /// request a preferred I/O mode for debug/testing.
+    /// see zbar_processor_request_iomode()
+    /// @since 0.7
+    void request_iomode (int iomode)
+    {
+        if(zbar_processor_request_iomode(_processor, iomode))
+            throw_exception(_processor);
+    }
+
+ private:
+    zbar_processor_t *_processor;
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Scanner.h

@@ -0,0 +1,162 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_SCANNER_H_
+#define _ZBAR_SCANNER_H_
+
+/// @file
+/// Scanner C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Scanner.h"
+#endif
+
+#include <stdio.h>
+
+namespace zbar {
+
+/// low-level linear intensity sample stream scanner interface.
+/// identifies "bar" edges and measures width between them.
+/// optionally passes to bar width Decoder
+
+class Scanner {
+ public:
+
+    /// constructor.
+    /// @param decoder reference to a Decoder instance which will
+    /// be passed scan results automatically
+    Scanner (Decoder& decoder)
+    {
+        _scanner = zbar_scanner_create(decoder._decoder);
+    }
+
+    /// constructor.
+    /// @param decoder pointer to a Decoder instance which will
+    /// be passed scan results automatically
+    Scanner (Decoder* decoder = NULL)
+    {
+        zbar_decoder_t *zdcode = NULL;
+        if(decoder)
+            zdcode = decoder->_decoder;
+        _scanner = zbar_scanner_create(zdcode);
+    }
+
+    ~Scanner ()
+    {
+        zbar_scanner_destroy(_scanner);
+    }
+
+    /// clear all scanner state.
+    /// see zbar_scanner_reset()
+    void reset ()
+    {
+        zbar_scanner_reset(_scanner);
+    }
+
+    /// mark start of a new scan pass.
+    /// see zbar_scanner_new_scan()
+    zbar_symbol_type_t new_scan ()
+    {
+        _type = zbar_scanner_new_scan(_scanner);
+        return(_type);
+    }
+
+    /// flush scanner pipeline.
+    /// see zbar_scanner_flush()
+    zbar_symbol_type_t flush ()
+    {
+        _type = zbar_scanner_flush(_scanner);
+        return(_type);
+    }
+
+    /// process next sample intensity value.
+    /// see zbar_scan_y()
+    zbar_symbol_type_t scan_y (int y)
+    {
+        _type = zbar_scan_y(_scanner, y);
+        return(_type);
+    }
+
+    /// process next sample intensity value.
+    /// see zbar_scan_y()
+    Scanner& operator<< (int y)
+    {
+        _type = zbar_scan_y(_scanner, y);
+        return(*this);
+    }
+
+    /// process next sample from RGB (or BGR) triple.
+    /// see zbar_scan_rgb24()
+    zbar_symbol_type_t scan_rgb24 (unsigned char *rgb)
+    {
+        _type = zbar_scan_rgb24(_scanner, rgb);
+        return(_type);
+    }
+
+    /// process next sample from RGB (or BGR) triple.
+    /// see zbar_scan_rgb24()
+    Scanner& operator<< (unsigned char *rgb)
+    {
+        _type = zbar_scan_rgb24(_scanner, rgb);
+        return(*this);
+    }
+
+    /// retrieve last scanned width.
+    /// see zbar_scanner_get_width()
+    unsigned get_width () const
+    {
+        return(zbar_scanner_get_width(_scanner));
+    }
+
+    /// retrieve last scanned color.
+    /// see zbar_scanner_get_color()
+    zbar_color_t get_color () const
+    {
+        return(zbar_scanner_get_color(_scanner));
+    }
+
+    /// retrieve last scan result.
+    zbar_symbol_type_t get_type () const
+    {
+        return(_type);
+    }
+
+    /// cast to C scanner
+    operator zbar_scanner_t* () const
+    {
+        return(_scanner);
+    }
+
+    /// retrieve C scanner
+    const zbar_scanner_t *get_c_scanner () const
+    {
+        return(_scanner);
+    }
+
+ private:
+    zbar_scanner_t *_scanner;
+    zbar_symbol_type_t _type;
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Symbol.h

@@ -0,0 +1,528 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_SYMBOL_H_
+#define _ZBAR_SYMBOL_H_
+
+/// @file
+/// Symbol C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Symbol.h"
+#endif
+
+#include <stdlib.h>
+#include <string>
+#include <ostream>
+#include <assert.h>
+
+namespace zbar {
+
+class SymbolIterator;
+
+/// container for decoded result symbols associated with an image
+/// or a composite symbol.
+
+class SymbolSet {
+public:
+    /// constructor.
+    SymbolSet (const zbar_symbol_set_t *syms = NULL)
+        : _syms(syms)
+    {
+        ref();
+    }
+
+    /// copy constructor.
+    SymbolSet (const SymbolSet& syms)
+        : _syms(syms._syms)
+    {
+        ref();
+    }
+
+    /// destructor.
+    ~SymbolSet ()
+    {
+        ref(-1);
+    }
+
+    /// assignment.
+    SymbolSet& operator= (const SymbolSet& syms)
+    {
+        syms.ref();
+        ref(-1);
+        _syms = syms._syms;
+        return(*this);
+    }
+
+    /// truth testing.
+    bool operator! () const
+    {
+        return(!_syms || !get_size());
+    }
+
+    /// manipulate reference count.
+    void ref (int delta = 1) const
+    {
+        if(_syms)
+            zbar_symbol_set_ref((zbar_symbol_set_t*)_syms, delta);
+    }
+
+    /// cast to C symbol set.
+    operator const zbar_symbol_set_t* () const
+    {
+        return(_syms);
+    }
+
+    int get_size () const
+    {
+        return((_syms) ? zbar_symbol_set_get_size(_syms) : 0);
+    }
+
+    /// create a new SymbolIterator over decoded results.
+    SymbolIterator symbol_begin() const;
+
+    /// return a SymbolIterator suitable for ending iteration.
+    const SymbolIterator symbol_end() const;
+
+private:
+    const zbar_symbol_set_t *_syms;
+};
+
+/// decoded barcode symbol result object.  stores type, data, and
+/// image location of decoded symbol
+
+class Symbol {
+public:
+
+    /// image pixel location (x, y) coordinate tuple.
+    class Point {
+    public:
+        int x;  ///< x-coordinate.
+        int y;  ///< y-coordinate.
+
+        Point () { }
+
+        Point(int x, int y)
+            : x(x), y(y)
+        { }
+
+        /// copy constructor.
+        Point (const Point& pt)
+            : x(pt.x),
+              y(pt.y)
+        { }
+
+        /// assignment.
+        Point& operator= (const Point& pt)
+        {
+            x = pt.x;
+            y = pt.y;
+            return(*this);
+        }
+    };
+
+    /// iteration over Point objects in a symbol location polygon.
+    class PointIterator
+        : public std::iterator<std::input_iterator_tag, Point> {
+
+    public:
+        /// constructor.
+        PointIterator (const Symbol *sym = NULL,
+                       int index = 0)
+            : _sym(sym),
+              _index(index)
+        {
+            sym->ref(1);
+            if(!sym ||
+               (unsigned)_index >= zbar_symbol_get_loc_size(*_sym))
+                _index = -1;
+        }
+
+        /// copy constructor.
+        PointIterator (const PointIterator& iter)
+            : _sym(iter._sym),
+              _index(iter._index)
+        {
+            _sym->ref();
+        }
+
+        /// destructor.
+        ~PointIterator ()
+        {
+            _sym->ref(-1);
+        }
+
+        /// assignment.
+        PointIterator& operator= (const PointIterator& iter)
+        {
+            iter._sym->ref();
+            _sym->ref(-1);
+            _sym = iter._sym;
+            _index = iter._index;
+            return(*this);
+        }
+
+        /// truth testing.
+        bool operator! () const
+        {
+            return(!_sym || _index < 0);
+        }
+
+        /// advance iterator to next Point.
+        PointIterator& operator++ ()
+        {
+            unsigned int i = ++_index;
+            if(i >= zbar_symbol_get_loc_size(*_sym))
+                _index = -1;
+            return(*this);
+        }
+
+        /// retrieve currently referenced Point.
+        const Point operator* () const
+        {
+            assert(!!*this);
+            if(!*this)
+                return(Point());
+            return(Point(zbar_symbol_get_loc_x(*_sym, _index),
+                         zbar_symbol_get_loc_y(*_sym, _index)));
+        }
+
+        /// test if two iterators refer to the same Point in the same
+        /// Symbol.
+        bool operator== (const PointIterator& iter) const
+        {
+            return(_index == iter._index &&
+                   ((_index < 0) || _sym == iter._sym));
+        }
+
+        /// test if two iterators refer to the same Point in the same
+        /// Symbol.
+        bool operator!= (const PointIterator& iter) const
+        {
+            return(!(*this == iter));
+        }
+
+    private:
+        const Symbol *_sym;
+        int _index;
+    };
+
+    /// constructor.
+    Symbol (const zbar_symbol_t *sym = NULL)
+        : _xmlbuf(NULL),
+          _xmllen(0)
+    {
+        init(sym);
+        ref();
+    }
+
+    /// copy constructor.
+    Symbol (const Symbol& sym)
+        : _sym(sym._sym),
+          _type(sym._type),
+          _data(sym._data),
+          _xmlbuf(NULL),
+          _xmllen(0)
+    {
+        ref();
+    }
+
+    /// destructor.
+    ~Symbol () {
+        if(_xmlbuf)
+            free(_xmlbuf);
+        ref(-1);
+    }
+
+    /// assignment.
+    Symbol& operator= (const Symbol& sym)
+    {
+        sym.ref(1);
+        ref(-1);
+        _sym = sym._sym;
+        _type = sym._type;
+        _data = sym._data;
+        return(*this);
+    }
+
+    Symbol& operator= (const zbar_symbol_t *sym)
+    {
+        if(sym)
+            zbar_symbol_ref(sym, 1);
+        ref(-1);
+        init(sym);
+        return(*this);
+    }
+
+    /// truth testing.
+    bool operator! () const
+    {
+        return(!_sym);
+    }
+
+    void ref (int delta = 1) const
+    {
+        if(_sym)
+            zbar_symbol_ref((zbar_symbol_t*)_sym, delta);
+    }
+
+    /// cast to C symbol.
+    operator const zbar_symbol_t* () const
+    {
+        return(_sym);
+    }
+
+    /// test if two Symbol objects refer to the same C symbol.
+    bool operator== (const Symbol& sym) const
+    {
+        return(_sym == sym._sym);
+    }
+
+    /// test if two Symbol objects refer to the same C symbol.
+    bool operator!= (const Symbol& sym) const
+    {
+        return(!(*this == sym));
+    }
+
+    /// retrieve type of decoded symbol.
+    zbar_symbol_type_t get_type () const
+    {
+        return(_type);
+    }
+
+    /// retrieve the string name of the symbol type.
+    const std::string get_type_name () const
+    {
+        return(zbar_get_symbol_name(_type));
+    }
+
+    /// retrieve the string name for any addon.
+    /// @deprecated in 0.11
+    const std::string get_addon_name () const
+    {
+        return(zbar_get_addon_name(_type));
+    }
+
+    /// retrieve data decoded from symbol.
+    const std::string get_data () const
+    {
+        return(_data);
+    }
+
+    /// retrieve length of binary data
+    unsigned get_data_length () const
+    {
+        return((_sym) ? zbar_symbol_get_data_length(_sym) : 0);
+    }
+
+    /// retrieve inter-frame coherency count.
+    /// see zbar_symbol_get_count()
+    /// @since 1.5
+    int get_count () const
+    {
+        return((_sym) ? zbar_symbol_get_count(_sym) : -1);
+    }
+
+    SymbolSet get_components () const
+    {
+        return(SymbolSet((_sym) ? zbar_symbol_get_components(_sym) : NULL));
+    }
+
+    /// create a new PointIterator at the start of the location
+    /// polygon.
+    PointIterator point_begin() const
+    {
+        return(PointIterator(this));
+    }
+
+    /// return a PointIterator suitable for ending iteration.
+    const PointIterator point_end() const
+    {
+        return(PointIterator());
+    }
+
+    /// see zbar_symbol_get_loc_size().
+    int get_location_size () const
+    {
+        return((_sym) ? zbar_symbol_get_loc_size(_sym) : 0);
+    }
+
+    /// see zbar_symbol_get_loc_x().
+    int get_location_x (unsigned index) const
+    {
+        return((_sym) ? zbar_symbol_get_loc_x(_sym, index) : -1);
+    }
+
+    /// see zbar_symbol_get_loc_y().
+    int get_location_y (unsigned index) const
+    {
+        return((_sym) ? zbar_symbol_get_loc_y(_sym, index) : -1);
+    }
+
+    /// see zbar_symbol_get_orientation().
+    /// @since 0.11
+    int get_orientation () const
+    {
+        return(zbar_symbol_get_orientation(_sym));
+    }
+
+    /// see zbar_symbol_xml().
+    const std::string xml () const
+    {
+        if(!_sym)
+            return("");
+        return(zbar_symbol_xml(_sym, (char**)&_xmlbuf, (unsigned*)&_xmllen));
+    }
+
+protected:
+    /// (re)initialize Symbol from C symbol object.
+    void init (const zbar_symbol_t *sym = NULL)
+    {
+        _sym = sym;
+        if(sym) {
+            _type = zbar_symbol_get_type(sym);
+            _data = std::string(zbar_symbol_get_data(sym),
+                                zbar_symbol_get_data_length(sym));
+        }
+        else {
+            _type = ZBAR_NONE;
+            _data = "";
+        }
+    }
+
+private:
+    const zbar_symbol_t *_sym;
+    zbar_symbol_type_t _type;
+    std::string _data;
+    char *_xmlbuf;
+    unsigned _xmllen;
+};
+
+/// iteration over Symbol result objects in a scanned Image or SymbolSet.
+class SymbolIterator
+    : public std::iterator<std::input_iterator_tag, Symbol> {
+
+public:
+    /// default constructor.
+    SymbolIterator ()
+    { }
+
+    /// constructor.
+    SymbolIterator (const SymbolSet &syms)
+        : _syms(syms)
+    {
+        const zbar_symbol_set_t *zsyms = _syms;
+        if(zsyms)
+            _sym = zbar_symbol_set_first_symbol(zsyms);
+    }
+
+    /// copy constructor.
+    SymbolIterator (const SymbolIterator& iter)
+        : _syms(iter._syms)
+    {
+        const zbar_symbol_set_t *zsyms = _syms;
+        if(zsyms)
+            _sym = zbar_symbol_set_first_symbol(zsyms);
+    }
+
+    ~SymbolIterator ()
+    {
+    }
+
+    /// assignment.
+    SymbolIterator& operator= (const SymbolIterator& iter)
+    {
+        _syms = iter._syms;
+        _sym = iter._sym;
+        return(*this);
+    }
+
+    bool operator! () const
+    {
+        return(!_syms || !_sym);
+    }
+
+    /// advance iterator to next Symbol.
+    SymbolIterator& operator++ ()
+    {
+        if(!!_sym)
+            _sym = zbar_symbol_next(_sym);
+        else if(!!_syms)
+            _sym = zbar_symbol_set_first_symbol(_syms);
+        return(*this);
+    }
+
+    /// retrieve currently referenced Symbol.
+    const Symbol operator* () const
+    {
+        return(_sym);
+    }
+
+    /// access currently referenced Symbol.
+    const Symbol* operator-> () const
+    {
+        return(&_sym);
+    }
+
+    /// test if two iterators refer to the same Symbol
+    bool operator== (const SymbolIterator& iter) const
+    {
+        // it is enough to test the symbols, as they belong
+        // to only one set (also simplifies invalid case)
+        return(_sym == iter._sym);
+    }
+
+    /// test if two iterators refer to the same Symbol
+    bool operator!= (const SymbolIterator& iter) const
+    {
+        return(!(*this == iter));
+    }
+
+    const SymbolIterator end () const {
+        return(SymbolIterator());
+    }
+
+private:
+    SymbolSet _syms;
+    Symbol _sym;
+};
+
+inline SymbolIterator SymbolSet::symbol_begin () const {
+    return(SymbolIterator(*this));
+}
+
+inline const SymbolIterator SymbolSet::symbol_end () const {
+    return(SymbolIterator());
+}
+
+/// @relates Symbol
+/// stream the string representation of a Symbol.
+static inline std::ostream& operator<< (std::ostream& out,
+                                        const Symbol& sym)
+{
+    out << sym.get_type_name() << ":" << sym.get_data();
+    return(out);
+}
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Video.h

@@ -0,0 +1,170 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_VIDEO_H_
+#define _ZBAR_VIDEO_H_
+
+/// @file
+/// Video Input C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Video.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level video source abstraction.
+/// captures images from a video device
+
+class Video {
+public:
+    /// constructor.
+    Video (zbar_video_t *video = NULL)
+    {
+        if(video)
+            _video = video;
+        else
+            _video = zbar_video_create();
+    }
+
+    /// constructor.
+    Video (std::string& device)
+    {
+        _video = zbar_video_create();
+        open(device);
+    }
+
+    ~Video ()
+    {
+        zbar_video_destroy(_video);
+    }
+
+    /// cast to C video object.
+    operator zbar_video_t* () const
+    {
+        return(_video);
+    }
+
+    /// open and probe a video device.
+    void open (std::string& device)
+    {
+        if(zbar_video_open(_video, device.c_str()))
+            throw_exception(_video);
+    }
+
+    /// close video device if open.
+    void close ()
+    {
+        if(zbar_video_open(_video, NULL))
+            throw_exception(_video);
+    }
+
+    /// initialize video using a specific format for debug.
+    /// see zbar_video_init()
+    void init (unsigned long fourcc)
+    {
+        if(zbar_video_init(_video, fourcc))
+            throw_exception(_video);
+    }
+
+    /// initialize video using a specific format for debug.
+    /// see zbar_video_init()
+    void init (std::string& format)
+    {
+        unsigned int fourcc = zbar_fourcc_parse(format.c_str());
+        if(zbar_video_init(_video, fourcc))
+            throw_exception(_video);
+    }
+
+    /// retrieve file descriptor associated with open *nix video device.
+    /// see zbar_video_get_fd()
+    int get_fd ()
+    {
+        return(zbar_video_get_fd(_video));
+    }
+
+    /// retrieve current output image width.
+    /// see zbar_video_get_width()
+    int get_width ()
+    {
+        return(zbar_video_get_width(_video));
+    }
+
+    /// retrieve current output image height.
+    /// see zbar_video_get_height()
+    int get_height ()
+    {
+        return(zbar_video_get_height(_video));
+    }
+
+    /// start/stop video capture.
+    /// see zbar_video_enable()
+    void enable (bool enable = true)
+    {
+        if(zbar_video_enable(_video, enable))
+            throw_exception(_video);
+    }
+
+    /// retrieve next captured image.
+    /// see zbar_video_next_image()
+    Image next_image ()
+    {
+        zbar_image_t *img = zbar_video_next_image(_video);
+        if(!img)
+            throw_exception(_video);
+        return(Image(img));
+    }
+
+    /// request a preferred size for the video image from the device.
+    /// see zbar_video_request_size()
+    /// @since 0.6
+    void request_size (int width, int height)
+    {
+        zbar_video_request_size(_video, width, height);
+    }
+
+    /// request a preferred driver interface version for debug/testing.
+    /// see zbar_video_request_interface()
+    /// @since 0.6
+    void request_interface (int version)
+    {
+        zbar_video_request_interface(_video, version);
+    }
+
+    /// request a preferred I/O mode for debug/testing.
+    /// see zbar_video_request_iomode()
+    /// @since 0.7
+    void request_iomode (int iomode)
+    {
+        if(zbar_video_request_iomode(_video, iomode))
+            throw_exception(_video);
+    }
+
+private:
+    zbar_video_t *_video;
+};
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Headers/ZBarSDK/zbar/Window.h

@@ -0,0 +1,136 @@
+//------------------------------------------------------------------------
+//  Copyright 2007-2009 (c) Jeff Brown <spadix@users.sourceforge.net>
+//
+//  This file is part of the ZBar Bar Code Reader.
+//
+//  The ZBar Bar Code Reader is free software; you can redistribute it
+//  and/or modify it under the terms of the GNU Lesser Public License as
+//  published by the Free Software Foundation; either version 2.1 of
+//  the License, or (at your option) any later version.
+//
+//  The ZBar Bar Code Reader is distributed in the hope that it will be
+//  useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+//  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//  GNU Lesser Public License for more details.
+//
+//  You should have received a copy of the GNU Lesser Public License
+//  along with the ZBar Bar Code Reader; if not, write to the Free
+//  Software Foundation, Inc., 51 Franklin St, Fifth Floor,
+//  Boston, MA  02110-1301  USA
+//
+//  http://sourceforge.net/projects/zbar
+//------------------------------------------------------------------------
+#ifndef _ZBAR_WINDOW_H_
+#define _ZBAR_WINDOW_H_
+
+/// @file
+/// Output Window C++ wrapper
+
+#ifndef _ZBAR_H_
+# error "include zbar.h in your application, **not** zbar/Window.h"
+#endif
+
+#include "Image.h"
+
+namespace zbar {
+
+/// mid-level output window abstraction.
+/// displays images to user-specified platform specific output window
+
+class Window {
+public:
+    /// constructor.
+    Window (zbar_window_t *window = NULL)
+    {
+        if(window)
+            _window = window;
+        else
+            _window = zbar_window_create();
+    }
+
+    /// constructor.
+    Window (void *x11_display_w32_hwnd,
+            unsigned long x11_drawable)
+    {
+        _window = zbar_window_create();
+        attach(x11_display_w32_hwnd, x11_drawable);
+    }
+
+    ~Window ()
+    {
+        zbar_window_destroy(_window);
+    }
+
+    /// cast to C window object.
+    operator zbar_window_t* () const
+    {
+        return(_window);
+    }
+
+    /// associate reader with an existing platform window.
+    /// see zbar_window_attach()
+    void attach (void *x11_display_w32_hwnd,
+                 unsigned long x11_drawable = 0)
+    {
+        if(zbar_window_attach(_window,
+                               x11_display_w32_hwnd, x11_drawable) < 0)
+            throw_exception(_window);
+    }
+
+    /// control content level of the reader overlay.
+    /// see zbar_window_set_overlay()
+    void set_overlay (int level)
+    {
+        zbar_window_set_overlay(_window, level);
+    }
+
+    /// retrieve current content level of reader overlay.
+    /// see zbar_window_get_overlay()
+
+    /// draw a new image into the output window.
+    /// see zbar_window_draw()
+    void draw (Image& image)
+    {
+        if(zbar_window_draw(_window, image) < 0)
+            throw_exception(_window);
+    }
+
+    /// clear the image from the output window.
+    /// see zbar_window_draw()
+    void clear ()
+    {
+        if(zbar_window_draw(_window, NULL) < 0)
+            throw_exception(_window);
+    }
+
+    /// redraw the last image.
+    /// zbar_window_redraw()
+    void redraw ()
+    {
+        if(zbar_window_redraw(_window) < 0)
+            throw_exception(_window);
+    }
+
+    /// resize the image window.
+    /// zbar_window_resize()
+    void resize (unsigned width, unsigned height)
+    {
+        if(zbar_window_resize(_window, width, height) < 0)
+            throw_exception(_window);
+    }
+
+private:
+    zbar_window_t *_window;
+};
+
+/// select a compatible format between video input and output window.
+/// see zbar_negotiate_format()
+static inline void negotiate_format (Video& video, Window& window)
+{
+    if(zbar_negotiate_format(video, window) < 0)
+        throw_exception(video);
+}
+
+}
+
+#endif

tools/simple_config_wizard/iOS/SimpleConfigWizard/SimpleConfig/Lib/ZBarSDK/Resources/zbar-help.html

@@ -0,0 +1,88 @@
+<?xml version="1.0"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<!--
+Copyright 2009-2010 (c) Jeff Brown <spadix@users.sourceforge.net>
+All Rights Reserved
+-->
+<html>
+<head>
+<title>Barcode Reader Help</title>
+<style type="text/css">
+html, body { margin: 0; padding: 0; background: black; color: white; font-family: sans-serif; font-size: 16px }
+h1 { margin: .5em 0; text-align: center; font-size: 28px }
+h2 { font-size: 24px }
+hr { margin: 1em 0; height: 0; border: none; border-top: solid 1px #666 }
+.smaller { font-size: 85% }
+p { margin: .5em }
+a { color: #8af }
+p.cen { text-align: center }
+p.title { margin: 1em; clear: both; text-align: center }
+div.col { width: 50% }
+.clear { clear: both }
+.iconlist { position: relative; clear: both; margin: 4px 0; padding: 1px 0 }
+.icon { width: 64px; height: 64px; overflow: hidden; margin: 12px 16px; padding: 0; background: url("zbar-helpicons.png") no-repeat; font: bold 56px "Marker Felt"; text-align: center }
+.sample { display: block; height: 96px; overflow: hidden; margin: 12px auto; padding: 0; background: url("zbar-samples.png") no-repeat; text-align: center}
+.left { float: left }
+.right { float: right }
+.iconlist > p { margin: 10px }
+.iconlist > h2 { margin: 10px }
+</style>
+</head>
+<body>
+<h1 id="title" style="color: #f88">Barcode Reader Help</h1>
+<hr/>
+<p class="title">Recognized barcodes should look like</p>
+<div class="col left">
+<a class="sample" style="width: 118px; background-position: -96px" href="http://wikipedia.org/wiki/EAN-13"></a>
+<p class="cen"><a href="http://wikipedia.org/wiki/EAN-13">EAN/UPC<br/>Product Codes</a></p>
+</div>
+<div class="col right">
+<a class="sample" style="width: 96px" href="http://wikipedia.org/wiki/QR_Code"></a>
+<p class="cen"><a href="http://wikipedia.org/wiki/QR_Code">QR Codes</a></p>
+</div>
+<p class="clear cen smaller">Also recognized, but not shown:
+<a href="http://wikipedia.org/wiki/Code_128">Code 128</a>,
+<a href="http://wikipedia.org/wiki/DataBar">DataBar (RSS)</a>,
+<a href="http://en.wikipedia.org/wiki/Code_93">Code 93</a>,
+<a href="http://wikipedia.org/wiki/Code_39">Code 39</a> and
+<a href="http://wikipedia.org/wiki/Interleaved_2_of_5">Interleaved 2 of 5</a></p>
+<hr/>
+<p class="clear title">Hints for successful scanning</p>
+<div class="iconlist">
+<div class="icon left"></div>
+<p>Ensure there is plenty of</p>
+<h2 style="color: #ff4">Light</h2>
+</div>
+<div class="iconlist">
+<div class="icon left" style="background: none; color: #2d4">4"</div>
+<h2 style="color: #4f6">Distance</h2>
+<p>should be about 3 to 5 inches</p>
+</div>
+<div class="iconlist">
+<div class="icon left" style="background-position: 0 -64px"></div>
+<h2 style="color: #3ee">Shake</h2>
+<p>to force the camera to focus</p>
+</div>
+<div class="iconlist">
+<div class="icon left" style="background-position: 0 -128px"></div>
+<h2 style="color: #59f">Wait</h2>
+<p>for the autofocus to finish</p>
+</div>
+<div class="iconlist">
+<div class="icon left" style="background-position: 0 -192px"></div>
+<h2 style="color: #d5f">Hold Still</h2>
+<p>while the barcode is scanned</p>
+</div>
+<script type="text/javascript">
+function onZBarHelp(argv) {
+var title;
+switch(argv.reason) {
+case "INFO": break;
+case "FAIL": title = "No Barcode Detected"; break;
+}
+if(title) document.getElementById('title').textContent = title;
+}
+</script>
+</body>
+</html>