static void
isdn_net_ciscohdlck_slarp_send_request(isdn_net_local *mlp)
{
isdn_net_dev *idev;
struct sk_buff *skb;
unsigned char *p;
if (list_empty(&mlp->online)) {
isdn_BUG();
return;
}
idev = list_entry(mlp->online.next, isdn_net_dev, online);
skb = isdn_net_ciscohdlck_alloc_skb(idev, 4 + 14);
if (!skb)
return;
p = skb_put(skb, 4 + 14);
/* cisco header */
p += put_u8 (p, CISCO_ADDR_UNICAST);
p += put_u8 (p, CISCO_CTRL);
p += put_u16(p, CISCO_TYPE_SLARP);
/* slarp request */
p += put_u32(p, CISCO_SLARP_REQUEST);
p += put_u32(p, 0); // address
p += put_u32(p, 0); // netmask
p += put_u16(p, 0); // unused
isdn_net_write_super(idev, skb);
}
static int
isdn_ciscohdlck_header(struct sk_buff *skb, struct net_device *dev,
unsigned short type,
void *daddr, void *saddr, unsigned plen)
{
unsigned char *p = skb_push(skb, 4);
p += put_u8 (p, CISCO_ADDR_UNICAST);
p += put_u8 (p, CISCO_CTRL);
p += put_u16(p, type);
return 4;
}
static uint8_t pack_notify_value(const hrs_measurement_t *meas, uint16_t length, uint8_t *value)
{
uint8_t *ptr = &value[1];
uint8_t flags = 0;
if (meas->bpm > 255) {
flags |= HRM_FLAG_VAL_16BIT;
put_u16_inc(&ptr, meas->bpm);
} else {
put_u8_inc(&ptr, meas->bpm);
}
if (meas->has_energy_expended) {
flags |= HRM_FLAG_ENERGY_EXPENDED_PRESENT;
put_u16_inc(&ptr, meas->energy_expended);
}
if (meas->rr_num) {
int idx = 0;
flags |= HRM_FLAG_RR_INTERVAL_PRESENT;
while (idx < meas->rr_num && (length - (ptr - value)) >= sizeof(uint16_t)) {
put_u16_inc(&ptr, meas->rr[idx++]);
}
}
flags |= (meas->contact_supported ? HRM_FLAG_SENSOR_CONTACT_SUPPORTED : 0);
flags |= (meas->contact_detected ? HRM_FLAG_SENSOR_CONTACT_DETECTED : 0);
put_u8(value, flags);
return ptr - value;
}
// Our custom key handler function
void key_handler(uint8_t code, bool special)
{
put_str_P(uart, special ? PSTR("Special: ") : PSTR("Char: "));
put_c(uart, code); // the actual character
put_c(uart, ' '); // space
put_u8(uart, code); // as number
put_nl(uart); // crlf
}
static void
isdn_net_ciscohdlck_slarp_send_reply(isdn_net_dev *idev)
{
isdn_net_local *mlp = idev->mlp;
struct sk_buff *skb;
unsigned char *p;
struct in_device *in_dev = NULL;
u32 addr = 0; /* local ipv4 address */
u32 mask = 0; /* local netmask */
if ((in_dev = mlp->dev.ip_ptr) != NULL) {
/* take primary(first) address of interface */
struct in_ifaddr *ifa = in_dev->ifa_list;
if (ifa != NULL) {
addr = ifa->ifa_local;
mask = ifa->ifa_mask;
}
}
skb = isdn_net_ciscohdlck_alloc_skb(idev, 4 + 14);
if (!skb)
return;
p = skb_put(skb, 4 + 14);
/* cisco header */
p += put_u8 (p, CISCO_ADDR_UNICAST);
p += put_u8 (p, CISCO_CTRL);
p += put_u16(p, CISCO_TYPE_SLARP);
/* slarp reply, send own ip/netmask; if values are nonsense remote
* should think we are unable to provide it with an address via SLARP */
p += put_u32(p, CISCO_SLARP_REPLY);
p += put_u32(p, addr); // address
p += put_u32(p, mask); // netmask
p += put_u16(p, 0); // unused
isdn_net_write_super(idev, skb);
}
static void
put_func (Sophon_VM *vm, Sophon_IOFunc func, Sophon_Ptr data,
Sophon_Function *f)
{
StoreVarParams svp;
Sophon_U16 i;
SOPHON_ASSERT(!(f->flags & SOPHON_FUNC_FL_NATIVE));
if (f->name)
put_str(vm, func, data, f->name);
else
put_u32(func, data, 0);
put_u8(func, data, f->flags);
put_u8(func, data, f->argc);
put_u16(func, data, f->varc);
put_u16(func, data, f->stack_size);
put_u16(func, data, f->ibuf_size);
SOPHON_ASSERT(f->var_hash.count == f->varc + f->argc);
svp.func = func;
svp.data = data;
sophon_hash_for_each(vm, &f->var_hash, store_var, &svp);
func(data, f->f.ibuf, f->ibuf_size);
#ifdef SOPHON_LINE_INFO
put_u16(func, data, f->lbuf_size);
for (i = 0; i < f->lbuf_size; i++) {
put_u16(func, data, f->lbuf[i].line);
put_u16(func, data, f->lbuf[i].offset);
}
#endif
}
static void
put_value (Sophon_VM *vm, Sophon_IOFunc func, Sophon_Ptr data,
Sophon_Value v)
{
if (sophon_value_is_undefined(v)) {
put_u8(func, data, TAG_UNDEF);
} else if (sophon_value_is_null(v)) {
put_u8(func, data, TAG_NULL);
} else if (sophon_value_is_bool(v)) {
Sophon_Bool b;
b = sophon_value_to_bool(vm, v);
put_u8(func, data, TAG_BOOL);
put_u8(func, data, b ? 1 : 0);
} else if (sophon_value_is_string(v)) {
Sophon_String *str;
sophon_value_to_string(vm, v, &str);
put_u8(func, data, (str->gc_flags & SOPHON_GC_FL_INTERN) ?
TAG_INTERN_STRING : TAG_STRING);
put_str(vm, func, data, str);
} else if (sophon_value_is_number(v)) {
Sophon_Number n;
sophon_value_to_number(vm, v, &n);
if (n == (Sophon_Number)(Sophon_Int)(n)) {
put_u8(func, data, TAG_INT);
put_u32(func, data, (Sophon_Int)n);
} else {
put_u8(func, data, TAG_DOUBLE);
put_double(func, data, n);
}
} else {
SOPHON_ASSERT(0);
}
}
/* called via cisco_timer.function */
static void
isdn_net_ciscohdlck_slarp_send_keepalive(unsigned long data)
{
isdn_net_local *mlp = (isdn_net_local *) data;
isdn_net_dev *idev;
struct inl_cisco *cisco = mlp->inl_priv;
struct sk_buff *skb;
unsigned char *p;
unsigned long last_cisco_myseq = cisco->myseq;
int myseq_diff = 0;
if (list_empty(&mlp->online)) {
isdn_BUG();
return;
}
idev = list_entry(mlp->online.next, isdn_net_dev, online);
cisco->myseq++;
myseq_diff = cisco->myseq - cisco->mineseen;
if (cisco->line_state && (myseq_diff >= 3 || myseq_diff <= -3)) {
/* line up -> down */
cisco->line_state = 0;
printk (KERN_WARNING
"UPDOWN: Line protocol on Interface %s,"
" changed state to down\n", idev->name);
/* should stop routing higher-level data accross */
} else if (!cisco->line_state &&
myseq_diff >= 0 && myseq_diff <= 2) {
/* line down -> up */
cisco->line_state = 1;
printk (KERN_WARNING
"UPDOWN: Line protocol on Interface %s,"
" changed state to up\n", idev->name);
/* restart routing higher-level data accross */
}
if (cisco->debserint)
printk (KERN_DEBUG "%s: HDLC "
"myseq %u, mineseen %u%c, yourseen %u, %s\n",
idev->name, cisco->myseq, cisco->mineseen,
(last_cisco_myseq == cisco->mineseen) ? '*' : 040,
cisco->yourseq,
(cisco->line_state) ? "line up" : "line down");
skb = isdn_net_ciscohdlck_alloc_skb(idev, 4 + 14);
if (!skb)
return;
p = skb_put(skb, 4 + 14);
/* cisco header */
p += put_u8 (p, CISCO_ADDR_UNICAST);
p += put_u8 (p, CISCO_CTRL);
p += put_u16(p, CISCO_TYPE_SLARP);
/* slarp keepalive */
p += put_u32(p, CISCO_SLARP_KEEPALIVE);
p += put_u32(p, cisco->myseq);
p += put_u32(p, cisco->yourseq);
p += put_u16(p, 0xffff); // reliablity, always 0xffff
isdn_net_write_super(idev, skb);
mod_timer(&cisco->timer, jiffies + cisco->keepalive_period * HZ);
}
