/*
 * The client for performing SLP registration/discovery, called by dotsd.c
 * 
 * (c) Columbia University, 2004-2006, All Rights Reserved.
 * Author: Weibin Zhao
 */

#include "mod_dots.h"

#define SLP_OFLOW_FLAG  0x8000
#define SLP_FRESH_FLAG  0x4000
#define SLP_MCAST_FLAG  0x2000
#define SLP_NORMAL_FLAG 0x0000
#define SLP_HEADER_LEN  12
#define SLP_VERSION     2
#define SLP_EndOfExt    0
#define SLP_SrvRqst     1
#define SLP_SrvRply     2
#define SLP_SrvReg      3
#define SLP_SrvAck      5
#define SLP_AttrListExt 0x0002
#define SLP_MeshFwdExt  0x0006
#define SLP_RqstFwd     1
#define SLP_Fwded       2
#define SLP_SelectExt   0x4002
#define SLP_SortExt     0x4003
#define SLP_LangTag     "en"
#define SLP_PR          ""
#define SLP_SPI         ""
#define SLP_DotsType    "dotslash"
#define SLP_DotsScope   "dotslash"
#define MAXBUF          4096

typedef struct {
    int ver;
    int fid;
    int len;
    int flag;
    int neo;
    int xid;
    int tlen;
    char tag[MAXNAME];
} slp_header_t;

typedef struct {
    char url[MAXNAME];
    int  lifetime;
} slp_url_t;

/*-----------------------------------------------
 * Some basic functions for writing SLP messages
 *-----------------------------------------------*/

/*
 * Write SLP header to (*buf), without language tag
 * Thus, the length is fixed as 12
 */
int slp_write_header(char **buf, int fid, int len, int flag, int xid)
{
    write_int(&(*buf), SLP_VERSION, 1);
    write_int(&(*buf), fid,  1);
    write_int(&(*buf), len,  3);
    write_int(&(*buf), flag, 2);
    write_int(&(*buf), 0,    3); /* neo */
    write_int(&(*buf), xid,  2);
    return SLP_HEADER_LEN;
}

/*
 * Write the correct packet lenght in SLP header
 */
void slp_write_hlen(char *buf, int len)
{
    char *p = buf+2;
    write_int(&p, len, 3);      // set len in SLP header
}

/*
 * Adjust SLP message for adding an extension, added length is "alen"
 * (1) last extension's NEO links to new extension
 * (2) adjust packet length: plen += alen
 */
void slp_adjust_mesg(char *buf, int alen)
{
    char *p;
    int  plen, next_ext, last_ext_offset;

    p = buf + 2;
    plen = read_int(&p, 3);         // get existing packet len
    p = buf + 7;
    next_ext = read_int(&p, 3);     // read neo in header
    last_ext_offset = 7;
    while (next_ext != SLP_EndOfExt) {
        last_ext_offset = next_ext + 2;
        p = buf + last_ext_offset;
        next_ext = read_int(&p, 3); 
    }
    p = buf + last_ext_offset;
    write_int(&p, plen, 3);         // link new extension
    p = buf + 2;
    write_int(&p, plen+alen, 3);    // adjust message length
}

/*
 * Write a string to SLP message, the string is prefixed
 * by a short (16-bit) integer as its length
 * If the string is "", then only lenght zero is written
 */
int slp_write_string(char **buf, char *s)
{
    int len;
    if (s == NULL) return 0;
    len = strlen(s);
    write_int(&(*buf), len, 2);
    memcpy(*buf, s, len);
    *buf += len;
    return (2+len);
}

/*
 * Write a URL entry to SLP message
 */
int slp_write_url(char **buf, char *url, int lifetime)
{
    int len;
    write_int(&(*buf), 0, 1);        // reserved
    write_int(&(*buf), lifetime, 2); // lifetime
    len = strlen(url);
    write_int(&(*buf), len, 2);      // len of url
    memcpy(*buf, url, len);          // copy url
    *buf += len;
    write_int(&(*buf), 0, 1);        // num of auths
    return (6+len);
}

/*------------------ Write different SLP messages -----------------*/

/*
 * Write an SLP SrvRqst message into buf
 * Return: the message length in "buf"
 */
int slp_write_SrvRqst(char *buf, int xid, int flag, char *ltag, char *pr,
                      char *type, char *scope, char *pred, char *spi)
{
    char *p = buf;
    int  len = 0;

    len += slp_write_header(&p, SLP_SrvRqst, 0, flag, xid); // set len later
    len += slp_write_string(&p, ltag);
    len += slp_write_string(&p, pr);
    len += slp_write_string(&p, type);
    len += slp_write_string(&p, scope);
    len += slp_write_string(&p, pred);
    len += slp_write_string(&p, spi);
    slp_write_hlen(buf, len);           // set len now
    return len;
}

/*
 * Write an SLP SrvRply message into buf
 * Return: the message length in "buf"
 */
int slp_write_SrvRply(char *buf, int xid, int flag, char *ltag,
                      int ecode, int count, slp_url_t *url_list)
{
    char *p = buf;
    int  i, len = 0;

    len += slp_write_header(&p, SLP_SrvRply, 0, flag, xid); // set len later
    len += slp_write_string(&p, ltag);
    len += write_int(&p, ecode, 2); 
    len += write_int(&p, count, 2);     
    for (i=0; i<count; i++) 
        len += slp_write_url(&p, url_list[i].url, url_list[i].lifetime);
    slp_write_hlen(buf, len);       // set len now
    return len;
}

/*
 * Write an SLP SrvReg message into "buf"
 * Return: the message length in "buf"
 */
int slp_write_SrvReg(char *buf, int xid, int flag, char *ltag, char *url,
                     int lifetime, char *type, char *scope, char *attr)
{
    char *p = buf;
    int  len = 0;

    len += slp_write_header(&p, SLP_SrvReg, 0, flag, xid); // set len later
    len += slp_write_string(&p, ltag);
    len += slp_write_url(&p, url, lifetime);
    len += slp_write_string(&p, type);
    len += slp_write_string(&p, scope);
    len += slp_write_string(&p, attr);
    len += write_int(&p, 0, 1);         // num of Auths
    slp_write_hlen(buf, len);           // set len now
    return len;
}

int slp_write_SrvAck(char *buf, int xid, int flag, char *ltag, int ecode)
{
    char *p = buf;
    int  len = 0;

    len += slp_write_header(&p, SLP_SrvAck, 0, flag, xid); // set len later
    len += slp_write_string(&p, ltag);
    len += write_int(&p, ecode, 2); 
    slp_write_hlen(buf, len);           // set len now
    return len;
}

int slp_write_MeshFwdExt(char *buf, int fwd_id, uint64_t ver_ts,
                         char *accept_da, uint64_t accept_ts)
{
    char *p = buf+2;                            // SLP packet len
    int  len = read_int(&p, 3);
    int  alen = 0;                              // added len
    
    p = buf+len;                                // move to the end;
    alen += write_int(&p, SLP_MeshFwdExt, 2);
    alen += write_int(&p, 0, 3);                // neo
    alen += write_int(&p, fwd_id, 1);
    alen += write_long(&p, ver_ts); 
    alen += write_long(&p, accept_ts);  
    alen += slp_write_string(&p, accept_da);
    slp_adjust_mesg(buf, alen);
    return (len+alen);
}

int slp_write_SelectExt(char *buf, int count)
{
    char *p = buf+2;                            // SLP packet len
    int  len = read_int(&p, 3);
    int  alen = 0;                              // added len
    
    p = buf+len;                                // move to the end;
    alen += write_int(&p, SLP_SelectExt, 2);
    alen += write_int(&p, 0, 3);                // neo
    alen += write_int(&p, count, 2);
    slp_adjust_mesg(buf, alen);
    return (len+alen);
}

int slp_write_SortExt(char *buf, char *sort_key)
{
    char *p = buf+2;                            // SLP packet len
    int  len = read_int(&p, 3);
    int  alen = 0;                              // added len
    
    p = buf+len;                                // move to the end;
    alen += write_int(&p, SLP_SortExt, 2);
    alen += write_int(&p, 0, 3);                // neo
    alen += slp_write_string(&p, sort_key);
    slp_adjust_mesg(buf, alen);
    return (len+alen);
}

int slp_write_AttrListExt(char *buf, char *url, char *attr)
{
    char *p = buf+2;                            // SLP packet len
    int  len = read_int(&p, 3);
    int  alen = 0;                              // added len
    
    p = buf+len;                                // move to the end;
    alen += write_int(&p, SLP_AttrListExt, 2);
    alen += write_int(&p, 0, 3);                // neo
    alen += slp_write_string(&p, url);
    alen += slp_write_string(&p, attr);
    alen += write_int(&p, 0, 1);                // num of Auths
    slp_adjust_mesg(buf, alen);
    return (len+alen);
}

/*-----------------------------------------------
 * Some basic functions for reading SLP messages
 *-----------------------------------------------*/

/*
 * Read SLP header, including language tag
 */
void slp_read_header(char **buf, slp_header_t *h) 
{
    h->ver  = read_int(&(*buf), 1);
    h->fid  = read_int(&(*buf), 1);
    h->len  = read_int(&(*buf), 3);
    h->flag = read_int(&(*buf), 2);
    h->neo  = read_int(&(*buf), 3);
    h->xid  = read_int(&(*buf), 2);
    h->tlen = read_int(&(*buf), 2);
    memcpy(h->tag, *buf, h->tlen);
    h->tag[h->tlen] = '\0';         // as a string
    *buf += h->tlen;

/*
    printf("ver=%d\n",  h->ver);
    printf("fid=%d\n",  h->fid);
    printf("len=%d\n",  h->len);
    printf("flag=%x\n", h->flag);
    printf("neo=%d\n",  h->neo);
    printf("xid=%d\n",  h->xid);
    printf("tlen=%d\n", h->tlen);
    printf("tag=%s\n",  h->tag);
*/
}

/*
 * Read a string from SLP message
 */
void slp_read_string(char **buf, char *s)
{
    int len = read_int(&(*buf), 2);
    s[0] = '\0';                    // default is empty string
    if (len == 0xFFFF) strcpy(s, "*");
    else if (len > 0) {
        memcpy(s, *buf, len);
        s[len] = '\0';              // as a string
        *buf += len;
    }
}

/* 
 * Read a URL entry from SLP message
 */
void slp_read_url(char **buf, char *url, int *lifetime)
{
    int dummy, len;

    dummy     = read_int(&(*buf), 1);   // reserved
    *lifetime = read_int(&(*buf), 2);
    len       = read_int(&(*buf), 2);
    memcpy(url, *buf, len);
    url[len]  = '\0';                   // as a string
    *buf     += len;
    dummy     = read_int(&(*buf), 1);   // num of auths
}

/*-------------------- Read different SLP messages -------------------*/

void slp_read_SrvRqst(char **buf) 
{
    char pr[MAXNAME], type[MAXNAME], scope[MAXNAME];
    char pred[MAXNAME], spi[MAXNAME];

    slp_read_string(&(*buf), pr);
    slp_read_string(&(*buf), type);
    slp_read_string(&(*buf), scope);
    slp_read_string(&(*buf), pred);
    slp_read_string(&(*buf), spi);
/*
    printf("pr=%s\n",    pr);
    printf("type=%s\n",  type);
    printf("scope=%s\n", scope);
    printf("pred=%s\n",  pred);
    printf("spi=%s\n",   spi);
*/
}

void slp_read_SrvRply(char **buf) 
{
    int i, ecode, count, lifetime;
    char url[MAXNAME];

    ecode = read_int(&(*buf), 2);
    count = read_int(&(*buf), 2);
/*
    fprintf(stderr, "ecode=%d, count=%d\n", ecode, count);
*/
    for (i=0; i<count; i++) {
        slp_read_url(&(*buf), url, &lifetime);
/*
        fprintf(stderr, "url=%s, lifetime=%d\n", url, lifetime);
*/
    }
}

void slp_read_SrvReg(char **buf) 
{
    int  lifetime, dummy;
    char url[MAXNAME], type[MAXNAME], scope[MAXNAME], attr[MAXNAME];

    slp_read_url(&(*buf), url, &lifetime);
    slp_read_string(&(*buf), type);
    slp_read_string(&(*buf), scope);
    slp_read_string(&(*buf), attr);
    dummy = read_int(&(*buf), 1);   // num of auths
/*
    printf("url=%s, lifetime=%d\n", url, lifetime);
    printf("type=%s\n",  type);
    printf("scope=%s\n", scope);
    printf("attr=%s\n",  attr);
*/
}

void slp_read_SrvAck(char **buf) 
{
    int ecode;

    ecode = read_int(&(*buf), 2);
    if (ecode != 0) {
        fprintf(stderr, "Register error: ecode=%d\n", ecode);
        fflush(stderr);
    }
}

void slp_read_extension(char **buf) 
{
    int ext_id, neo;

    do {
        ext_id = read_int(&(*buf), 2);
        neo    = read_int(&(*buf), 3);
        if (ext_id == SLP_MeshFwdExt) {
            char accept_da[MAXNAME];
            int fwd_id = read_int(&(*buf), 1);
            uint64_t ver_ts = read_long(&(*buf));
            uint64_t accept_ts = read_long(&(*buf));
            slp_read_string(&(*buf), accept_da);
/*
            printf("ext_id=%x, fwd_id=%d, ver_ts=%llx, accept_ts=%llx,"
                   " accept_da=%s\n", ext_id, fwd_id, ver_ts, accept_ts, 
                   accept_da);
*/
        } else if (ext_id == SLP_SelectExt) {
            int count = read_int(&(*buf), 2);
/*
            fprintf(stderr, "ext_id=%x, count=%d\n", ext_id, count);
*/
        } else if (ext_id == SLP_SortExt) {
            char sort_key[MAXNAME];
            slp_read_string(&(*buf), sort_key);
/*
            printf("ext_id=%x, sort_key=%s\n", ext_id, sort_key);
*/
        } else if (ext_id == SLP_AttrListExt) {
            char url[MAXNAME], attr[MAXNAME];
            int  dummy;
            slp_read_string(&(*buf), url);
            slp_read_string(&(*buf), attr);
            dummy = read_int(&(*buf), 1);
/*
            fprintf(stderr, "ext_id=%x, url=%s, attr=%s\n", ext_id, url, attr);
*/
            append_ctable(url, attr);
        }
    } while (neo != SLP_EndOfExt);
}

void network_sendrecv(char *buf, int len)
{
    char *p = buf;
    slp_header_t h;
    int  n;

    sendto(srvloc_sockfd, buf, len, 0,
           (SA *)&srvloc_servaddr, sizeof(srvloc_servaddr));

    n = recvfrom(srvloc_sockfd, buf, MAXBUF, 0, NULL, NULL);

    slp_read_header(&p, &h);

    if (h.fid == SLP_SrvRqst)      slp_read_SrvRqst(&p);
    else if (h.fid == SLP_SrvRply) slp_read_SrvRply(&p);
    else if (h.fid == SLP_SrvReg)  slp_read_SrvReg(&p);
    else if (h.fid == SLP_SrvAck)  slp_read_SrvAck(&p);

    if (h.neo != SLP_EndOfExt) slp_read_extension(&p);
}

void slp_register(char *hostname, int dotsd_port, int link_rate, 
                  float cpu_rate) 
{
    char buf[MAXBUF], url[MAXNAME], attr[MAXNAME];
    int  len, xid=1, lifetime;

    if (srvloc_sockfd == -1) return; // no service discovery
    sprintf(url,  "%s://%s:%d", SLP_DotsType, hostname, dotsd_port);
    sprintf(attr, "(LinkRate=%d),(CpuRate=%4.2f),(IP=%s)", 
            link_rate, cpu_rate, my_ip); 
    lifetime = RegisterTTL * ControlInterval + 10;
    len = slp_write_SrvReg(buf, xid, SLP_FRESH_FLAG, SLP_LangTag,
                           url, lifetime, SLP_DotsType, SLP_DotsScope, attr);
    network_sendrecv(buf, len);
}

void slp_discover(int min_link, float min_cpu)
{
    char buf[MAXBUF], attr[MAXNAME], sort_key[]="LinkRate:i:-,CpuRate:i:-";
    int  len;

    if (srvloc_sockfd == -1) return; // no service discovery
    sprintf(attr, "&(LinkRate>=%d)(CpuRate>=%4.2f)", min_link, min_cpu);
    len = slp_write_SrvRqst(buf, 1, SLP_NORMAL_FLAG, SLP_LangTag, SLP_PR, 
                            SLP_DotsType, SLP_DotsScope, attr, SLP_SPI);
    len = slp_write_SortExt(buf, sort_key);
    len = slp_write_SelectExt(buf, 20);
    len = slp_write_AttrListExt(buf, "", "");
    network_sendrecv(buf, len);
}