static int get_pfc_state(char *ifname, __u8 *state) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta; nlh = start_msg(RTM_GETDCB, DCB_CMD_PFC_GSTATE); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); if (send_msg(nlh)) return -EIO; free(nlh); nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_PFC_GSTATE) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta->rta_type != DCB_ATTR_PFC_STATE) { return -EIO; } *state = *(__u8 *)NLA_DATA(rta); return 0; }
/* * Start a new message */ void Filter::new_msg() { start_msg(); for(size_t j = 0; j != total_ports(); ++j) if(m_next[j]) m_next[j]->new_msg(); }
int set_ieee(char *ifname, struct ieee_ets *ets_data, struct ieee_pfc *pfc_data, struct dcb_app *app_data) { struct nlmsghdr *nlh; struct rtattr *ieee, *apptbl; nlh = start_msg(RTM_SETDCB, DCB_CMD_IEEE_SET); if (NULL == nlh) return -EIO; addattr_l(nlh, DCB_ATTR_IFNAME, ifname, strlen(ifname) + 1); ieee = addattr_nest(nlh, DCB_ATTR_IEEE); if (ets_data) addattr_l(nlh, DCB_ATTR_IEEE_ETS, ets_data, sizeof(*ets_data)); if (pfc_data) addattr_l(nlh, DCB_ATTR_IEEE_PFC, pfc_data, sizeof(*pfc_data)); if (app_data) { apptbl = addattr_nest(nlh, DCB_ATTR_IEEE_APP_TABLE); addattr_l(nlh, DCB_ATTR_IEEE_APP, app_data, sizeof(*app_data)); #if 1 app_data->protocol++; addattr_l(nlh, DCB_ATTR_IEEE_APP, app_data, sizeof(*app_data)); #endif addattr_nest_end(nlh, apptbl); } addattr_nest_end(nlh, ieee); if (send_msg(nlh)) return -EIO; return recv_msg(DCB_CMD_IEEE_SET, DCB_ATTR_IEEE); }
int set_hw_app0(char *ifname, appgroup_attribs *app_data) { struct nlmsghdr *nlh; struct rtattr *rta_parent, *rta_child; printf("set_hw_app0: %s\n", ifname); nlh = start_msg(RTM_SETDCB, DCB_CMD_SAPP); if (NULL == nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_APP, NULL, 0); rta_child = add_rta(nlh, DCB_APP_ATTR_IDTYPE, (void *)&app_data->dcb_app_idtype, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_APP_ATTR_ID, (void *)&app_data->dcb_app_id, sizeof(__u16)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_APP_ATTR_PRIORITY, (void *)&app_data->dcb_app_priority, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; return(recv_msg(DCB_CMD_SAPP, DCB_ATTR_APP)); }
/************************************************* * Start a new message * *************************************************/ void Filter::new_msg() { start_msg(); for(u32bit j = 0; j != total_ports(); ++j) if(next[j]) next[j]->new_msg(); }
static int get_pfc_cfg(char *ifname, __u8 *pfc) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int i; nlh = start_msg(RTM_GETDCB, DCB_CMD_PFC_GCFG); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_PFC_CFG, NULL, 0); rta_child = add_rta(nlh, DCB_PFC_UP_ATTR_ALL, NULL, 0); rta_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_PFC_GCFG) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta_parent->rta_type != DCB_ATTR_PFC_CFG) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); for (i = 0; rta_parent > rta_child; i++) { if (i == 8) { printf("pfc array out of range\n"); break; } pfc[rta_child->rta_type - DCB_PFC_UP_ATTR_0] = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); } if (rta_parent != rta_child) printf("rta pointers are off\n"); return 0; }
static int make_msg(void) { const struct line* line; if ((line = buffer->read()) == 0) return 0; start_msg(line); while ((line = buffer->peek()) != 0) { if (!add_msg(line)) break; buffer->read(); } end_msg(); return 1; }
static int set_state(char *ifname, __u8 state) { struct nlmsghdr *nlh; nlh = start_msg(RTM_SETDCB, DCB_CMD_SSTATE); if (NULL == nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); add_rta(nlh, DCB_ATTR_STATE, (void *)&state, sizeof(__u8)); if (send_msg(nlh)) return -EIO; return(recv_msg(DCB_CMD_SSTATE, DCB_ATTR_STATE)); }
static int get_perm_hwaddr(char *ifname, __u8 *buf_perm, __u8 *buf_san) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta; nlh = start_msg(RTM_GETDCB, DCB_CMD_GPERM_HWADDR); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); add_rta(nlh, DCB_ATTR_PERM_HWADDR, NULL, 0); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) { printf("get msg failed\n"); return -EIO; } d = (struct dcbmsg *)NLMSG_DATA(nlh); rta = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_GPERM_HWADDR) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta->rta_type != DCB_ATTR_PERM_HWADDR) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } memcpy(buf_perm, NLA_DATA(rta), ETH_ALEN); memcpy(buf_san, NLA_DATA(rta + ETH_ALEN*sizeof(__u8)), ETH_ALEN); return 0; }
/* returns: 0 on success * 1 on failure */ static int set_numtcs(char *ifname, int tcid, __u8 numtcs) { struct nlmsghdr *nlh; struct rtattr *rta_parent, *rta_child; printf("set_numtcs_cfg: %s\n", ifname); nlh = start_msg(RTM_SETDCB, DCB_CMD_SNUMTCS); if (NULL == nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_NUMTCS, NULL, 0); rta_child = add_rta(nlh, tcid, &numtcs, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; return(recv_msg(DCB_CMD_SNUMTCS, DCB_ATTR_NUMTCS)); }
static int get_state(char *ifname, __u8 *state) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta; nlh = start_msg(RTM_GETDCB, DCB_CMD_GSTATE); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); if (send_msg(nlh)) return -EIO; free(nlh); nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_GSTATE) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta->rta_type != DCB_ATTR_STATE) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } *state = *(__u8 *)NLA_DATA(rta); return 0; }
/* * Process a full message at once */ void Pipe::process_msg(const byte input[], size_t length) { start_msg(); write(input, length); end_msg(); }
/* returns: 0 on success * 1 on failure */ static int set_bcn_cfg(char *ifname, bcn_cfg *bcn_data) { struct nlmsghdr *nlh; struct rtattr *rta_parent, *rta_child; int i; int temp_int; printf("set_bcn_cfg: %s\n", ifname); nlh = start_msg(RTM_SETDCB, DCB_CMD_BCN_SCFG); if (NULL == nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_BCN, NULL, 0); for (i = DCB_BCN_ATTR_RP_0; i <= DCB_BCN_ATTR_RP_7; i++) { rta_child = add_rta(nlh, i, (void *)&bcn_data->up_settings[i - DCB_BCN_ATTR_RP_0].rp_admin, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); } temp_int = 0; for (i = 0; i < BCN_ADDR_OPTION_LEN/2; i++) temp_int |= bcn_data->bcna[i]<<(i*8); rta_child = add_rta(nlh, DCB_BCN_ATTR_BCNA_0, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = 0; for (i = BCN_ADDR_OPTION_LEN/2; i < BCN_ADDR_OPTION_LEN; i++) temp_int |= bcn_data->bcna[i]<<((i- BCN_ADDR_OPTION_LEN/2)*8); rta_child = add_rta(nlh, DCB_BCN_ATTR_BCNA_1, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_ALPHA, (void *)&bcn_data->rp_alpha, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_BETA, (void *)&bcn_data->rp_beta, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_GD, (void *)&bcn_data->rp_gd, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_GI, (void *)&bcn_data->rp_gi, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_TMAX, (void *)&bcn_data->rp_tmax, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_td; rta_child = add_rta(nlh, DCB_BCN_ATTR_TD, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_rmin; rta_child = add_rta(nlh, DCB_BCN_ATTR_RMIN, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_w; rta_child = add_rta(nlh, DCB_BCN_ATTR_W, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_rd; rta_child = add_rta(nlh, DCB_BCN_ATTR_RD, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_ru; rta_child = add_rta(nlh, DCB_BCN_ATTR_RU, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); temp_int = (int)bcn_data->rp_wrtt; rta_child = add_rta(nlh, DCB_BCN_ATTR_WRTT, (void *)&temp_int, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_BCN_ATTR_RI, (void *)&bcn_data->rp_ri, sizeof(__u32)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; return(recv_msg(DCB_CMD_BCN_SCFG, DCB_ATTR_BCN)); }
static int get_bcn(char *ifname, bcn_cfg *bcn_data) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int i, j; unsigned int temp_int; nlh = start_msg(RTM_GETDCB, DCB_CMD_BCN_GCFG); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_BCN, NULL, 0); rta_child = add_rta(nlh, DCB_BCN_ATTR_ALL, NULL, 0); rta_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) { printf("error getting BCN cfg.\n"); return -EIO; } d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_BCN_GCFG) { printf("Hmm, this is not the message we were expecting.\n"); free(nlh); return -EIO; } if (rta_parent->rta_type != DCB_ATTR_BCN) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with rtnl and attribute support) " "would sure be nice.\n"); free(nlh); return -EIO; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); for (i = 0; rta_parent > rta_child; i++) { if (i == DCB_BCN_ATTR_RP_ALL - DCB_BCN_ATTR_RP_0) { printf("bcn param out of range\n"); break; } bcn_data->up_settings[rta_child->rta_type - DCB_BCN_ATTR_RP_0].rp_admin = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); } for (i = 0; i < BCN_ADDR_OPTION_LEN/4; i++) { /*2 bytes for BCNA data */ temp_int = *(__u32 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); for (j = 0; j < 4; j++) { bcn_data->bcna[j+i*4] = (__u8)((temp_int & (0xFF << (j*8))) >> (j*8)); } } memcpy((void *)&bcn_data->rp_alpha, (__u32 *)NLA_DATA(rta_child), sizeof(__u32)); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); memcpy((void *)&bcn_data->rp_beta, (__u32 *)NLA_DATA(rta_child), sizeof(__u32)); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); memcpy((void *)&bcn_data->rp_gd, (__u32 *)NLA_DATA(rta_child), sizeof(__u32)); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); memcpy((void *)&bcn_data->rp_gi, (__u32 *)NLA_DATA(rta_child), sizeof(__u32)); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_tmax = *(__u32 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_td = *(__u16 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_rmin = *(__u16 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_w = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_rd = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_ru = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_wrtt = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); bcn_data->rp_ri = *(__u32 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); if (rta_parent != rta_child) printf("rta pointers are off\n"); return 0; }
static int get_numtcs(char *ifname, int tcid, __u8 *numtcs) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int found; int i; nlh = start_msg(RTM_GETDCB, DCB_CMD_GNUMTCS); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_NUMTCS, NULL, 0); rta_child = add_rta(nlh, DCB_NUMTCS_ATTR_ALL, NULL, 0); rta_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_GNUMTCS) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta_parent->rta_type != DCB_ATTR_NUMTCS) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); found = 0; for (i = 0; rta_parent > rta_child; i++) { if (!found && rta_child->rta_type == tcid) { *numtcs = *(__u8 *)NLA_DATA(rta_child); found = 1; } rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); } if (rta_parent != rta_child) printf("rta pointers are off\n"); if (found) return 0; else return -1; }
static int get_cap(char *ifname, __u8 *cap) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int i; nlh = start_msg(RTM_GETDCB, DCB_CMD_GCAP); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_CAP, NULL, 0); rta_child = add_rta(nlh, DCB_CAP_ATTR_ALL, NULL, 0); rta_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_GCAP) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (rta_parent->rta_type != DCB_ATTR_CAP) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); for (i = 0; rta_parent > rta_child; i++) { if (i == 8) { printf("cap array out of range\n"); break; } cap[rta_child->rta_type] = *(__u8 *)NLA_DATA(rta_child); switch (rta_child->rta_type) { case DCB_CAP_ATTR_ALL: break; case DCB_CAP_ATTR_PG: printf("pg: "); break; case DCB_CAP_ATTR_PFC: printf("pfc: "); break; case DCB_CAP_ATTR_UP2TC: printf("up2tc: "); break; case DCB_CAP_ATTR_PG_TCS: printf("pg tcs: "); break; case DCB_CAP_ATTR_PFC_TCS: printf("pfc tcs: "); break; case DCB_CAP_ATTR_GSP: printf("gsp: "); break; case DCB_CAP_ATTR_BCN: printf("bcn: "); break; case DCB_CAP_ATTR_DCBX: printf("dcbx: "); break; default: printf("unknown type: "); break; } printf("%02x\n", cap[rta_child->rta_type]); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); } if (rta_parent != rta_child) printf("rta pointers are off\n"); return 0; }
static int get_app_cfg(char *ifname, appgroup_attribs *app_data) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *rta_parent, *rta_child; int rval = 0; __u8 idtype; __u16 id; nlh = start_msg(RTM_GETDCB, DCB_CMD_GAPP); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_APP, NULL, 0); rta_child = add_rta(nlh, DCB_APP_ATTR_IDTYPE, (void *)&app_data->dcb_app_idtype, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_APP_ATTR_ID, (void *)&app_data->dcb_app_id, sizeof(__u16)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); rta_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != DCB_CMD_GAPP) { printf("Hmm, this is not the message we were expecting.\n"); rval = -EIO; goto get_error; } if (rta_parent->rta_type != DCB_ATTR_APP) { printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); rval = -EIO; goto get_error; } rta_child = NLA_DATA(rta_parent); rta_parent = (struct rtattr *)((char *)rta_parent + NLMSG_ALIGN(rta_parent->rta_len)); idtype = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); if (idtype != app_data->dcb_app_idtype) { rval = -EIO; goto get_error; } id = *(__u16 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); if (id != app_data->dcb_app_id) { rval = -EIO; goto get_error; } app_data->dcb_app_priority = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); if (rta_parent != rta_child) printf("rta pointers are off\n"); get_error: free(nlh); return rval; }
/* * Process a full message at once */ void Pipe::process_msg(DataSource& input) { start_msg(); write(input); end_msg(); }
int get_ieee(char *ifname) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *dcb, *ieee[DCB_ATTR_IEEE_MAX+1]; struct rtattr *tb[DCB_ATTR_MAX + 1]; int len; nlh = start_msg(RTM_GETDCB, DCB_CMD_IEEE_GET); if (NULL == nlh) { printf("start_msg failed\n"); return -EIO; } addattr_l(nlh, DCB_ATTR_IFNAME, ifname, strlen(ifname) + 1); if (send_msg(nlh)) { printf("send failure\n"); return -EIO; } /* Receive 802.1Qaz parameters */ memset(nlh, 0, MAX_MSG_SIZE); len = recv(nl_sd, (void *)nlh, MAX_MSG_SIZE, 0); if (len < 0) { perror("ieee_get"); return -EIO; } if (nlh->nlmsg_type != RTM_GETDCB) { struct nlmsgerr *err = (struct nlmsgerr *) NLMSG_DATA(nlh); if (nlh->nlmsg_type == NLMSG_ERROR) { printf("NLMSG_ERROR: err(%i): %s\n", err->error, strerror(err->error * -1)); } return -1; } d = NLMSG_DATA(nlh); len -= NLMSG_LENGTH(sizeof(*d)); if (len < 0) { printf("Broken message\n"); return -1; } parse_rtattr(tb, DCB_ATTR_MAX, DCB_RTA(d), len); if (!tb[DCB_ATTR_IEEE]) { printf("Missing DCB_ATTR_IEEE attribute!\n"); return -1; } if (tb[DCB_ATTR_IFNAME]) { printf("\tifname %s\n", (char *)RTA_DATA(tb[DCB_ATTR_IFNAME])); } else { printf("Missing DCB_ATTR_IFNAME attribute!\n"); return -1; } dcb = tb[DCB_ATTR_IEEE]; parse_rtattr_nested(ieee, DCB_ATTR_IEEE_MAX, dcb); if (ieee[DCB_ATTR_IEEE_ETS]) { struct ieee_ets *ets = RTA_DATA(ieee[DCB_ATTR_IEEE_ETS]); print_ets(ets); } if (ieee[DCB_ATTR_IEEE_PFC]) { struct ieee_pfc *pfc = RTA_DATA(ieee[DCB_ATTR_IEEE_PFC]); print_pfc(pfc); } if (ieee[DCB_ATTR_IEEE_APP_TABLE]) { struct rtattr *i, *app_list = ieee[DCB_ATTR_IEEE_APP_TABLE]; int rem = RTA_PAYLOAD(app_list); printf("APP:\n"); for (i = RTA_DATA(app_list); RTA_OK(i, rem); i = RTA_NEXT(i, rem)) print_app(i); } return 0; }
int main(int argc, char *argv[]) { struct tc_config tc[8]; int i, err = 0; int newstate = -1; int read_only = 0; __u8 state; __u8 pfc[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; __u8 bwg[8] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; __u8 mac[ETH_ALEN], san_mac[ETH_ALEN]; __u8 cap[DCB_CAP_ATTR_MAX+1]; __u8 numtcs; bcn_cfg bcn_set_data, bcn_data; #ifdef DCB_APP_DRV_IF_SUPPORTED appgroup_attribs app_data = {DCB_APP_IDTYPE_ETHTYPE, 0x8906, 0x08}; #endif /* DCB_APP_DRV_IF_SUPPORTED */ int ifindex; int optind = 1; char *ifname; printf("Calling RTNETLINK interface.\n"); if (argc < 2) { fprintf(stderr, "usage: %s [-v] <ifname> [on|off|ro]\n", argv[0]); exit(1); } if (argc > 2) { if (!strcmp(argv[1], "-v")) { hexdump = 1; optind++; } if (argc > optind + 1) { if (!strcmp(argv[optind + 1], "on")) newstate = 1; if (!strcmp(argv[optind + 1], "off")) newstate = 0; if (!strcmp(argv[optind + 1], "ro")) read_only = 1; } } ifname = argv[optind]; ifindex = if_nametoindex(ifname); if (ifindex == 0) { printf("no ifindex for %s\n", ifname); exit(1); } if ((nl_sd = init_socket()) < 0) { fprintf(stderr, "error creating netlink socket\n"); return nl_sd; } #ifdef DO_GETLINK_QUERY printf("DOING A GETLINK COMMAND\n"); nlh = start_msg(RTM_GETLINK, ifindex); if (nlh == NULL) exit(1); if (send_msg(nlh)) exit(1); free(nlh); nlh = get_msg(); #endif printf("GETTING DCB STATE\n"); err = get_state(ifname, &state); if (err) { fprintf(stderr, "Error getting DCB state\n"); goto err_main; } printf("DCB State = %d\n", state); if (newstate >= 0) { printf("\nSETTING DCB STATE TO: %d\n", newstate); err = set_state(ifname, newstate); if (err) goto err_main; err = get_state(ifname, &state); if (err) { fprintf(stderr, "Error getting DCB state\n"); goto err_main; } printf("New DCB State = %d\n", state); } printf("\nGETTING PFC CONFIGURATION\n"); for (i=0; i<8; i++) pfc[i] = 0x0f; get_pfc_cfg(ifname, pfc); printf("PFC config:\n"); for (i=0; i<8; i++) printf("%x ", pfc[i]); printf("\n"); get_pfc_state(ifname, &state); if (err) { fprintf(stderr, "Error getting PFC status\n"); goto err_main; } printf("PFC State = %d\n", state); printf("\nGETTING PG TX CONFIGURATION\n"); get_pg(ifname, tc, bwg, DCB_CMD_PGTX_GCFG); for (i = 0; i < 8; i++) { printf("%d: pr=%d\tbwgid=%d\tbw%%=%d\tu2t=%d\tlk%%=%d\n", i, tc[i].prio_type, tc[i].bwg_id, tc[i].bwg_percent, tc[i].up_to_tc_bitmap, bwg[i]); tc[i].prio_type = 3; tc[i].bwg_id = i; tc[i].bwg_percent = 100; tc[i].up_to_tc_bitmap = i; bwg[i] = 12 + (i & 1); } printf("\nGETTING PG RX CONFIGURATION\n"); memset(bwg, 0, sizeof(bwg)); memset(&tc[0], 0, sizeof(tc)); get_pg(ifname, tc, bwg, DCB_CMD_PGRX_GCFG); for (i = 0; i < 8; i++) { printf("%d: pr=%d\tbwgid=%d\tbw%%=%d\tu2t=%d\tlk%%=%d\n", i, tc[i].prio_type, tc[i].bwg_id, tc[i].bwg_percent, tc[i].up_to_tc_bitmap, bwg[i]); } printf("\nGETTING PERMANENT MAC: "); get_perm_hwaddr(ifname, mac, san_mac); for (i = 0; i < 5; i++) printf("%02x:", mac[i]); printf("%02x\n", mac[i]); printf("\nGETTING SAN MAC: "); for (i = 0; i < 5; i++) printf("%02x:", san_mac[i]); printf("%02x\n", san_mac[i]); printf("\nGETTING DCB CAPABILITIES\n"); get_cap(ifname, &cap[0]); printf("\nGET NUMBER OF PG TCS\n"); if (!get_numtcs(ifname, DCB_NUMTCS_ATTR_PG, &numtcs)) printf("num = %d\n", numtcs); else printf("not found\n"); printf("\nGET NUMBER OF PFC TCS\n"); if (!get_numtcs(ifname, DCB_NUMTCS_ATTR_PFC, &numtcs)) printf("num = %d\n", numtcs); else printf("not found\n"); if (!read_only) { printf("\nTEST SET NUMBER OF PG TCS\n"); if (!set_numtcs(ifname, DCB_NUMTCS_ATTR_PG, numtcs)) printf("set passed\n"); else printf("error\n"); printf("\nTEST SET NUMBER OF PFC TCS\n"); if (!set_numtcs(ifname, DCB_NUMTCS_ATTR_PFC, numtcs)) printf("set passed\n"); else printf("error\n\n"); /* printf("set_pfc_cfg = %d\n", set_pfc_cfg(ifname, pfc)); */ /* printf("set_rx_pg = %d\n", set_pg(ifname, tc, bwg, DCB_CMD_PGRX_SCFG));*/ /* printf("set_hw_all = %d\n", set_hw_all(ifname)); */ err = set_hw_bcn(ifname, &bcn_set_data, 1); printf("set_bcn_cfg result is %d.\n", err); /*set_hw_all(ifname);*/ } printf("\nGETTING BCN:\n"); if (!get_bcn(ifname, &bcn_data)) { for (i = 0; i < 8; i++) { printf("BCN RP %d: %d\n", i, bcn_data.up_settings[i].rp_admin); } printf("\nBCN RP ALPHA: %f\n", bcn_data.rp_alpha); printf("BCN RP BETA : %f\n", bcn_data.rp_beta); printf("BCN RP GD : %f\n", bcn_data.rp_gd); printf("BCN RP GI : %f\n", bcn_data.rp_gi); printf("BCN RP TMAX : %d\n", bcn_data.rp_tmax); printf("BCN RP RI : %d\n", bcn_data.rp_ri); printf("BCN RP TD : %d\n", bcn_data.rp_td); printf("BCN RP RMIN : %d\n", bcn_data.rp_rmin); printf("BCN RP W : %d\n", bcn_data.rp_w); printf("BCN RP RD : %d\n", bcn_data.rp_rd); printf("BCN RP RU : %d\n", bcn_data.rp_ru); printf("BCN RP WRTT : %d\n", bcn_data.rp_wrtt); } else printf("not found\n"); #ifdef DCB_APP_DRV_IF_SUPPORTED if (!read_only) { printf("\nSETTING APP:\n"); if (set_hw_app0(ifname, &app_data)) { printf("Fail to set app data.\n"); goto err_main; } } printf("\nGETTING APP:\n"); if (!get_app_cfg(ifname, &app_data)) { printf("APP ID TYPE: "); if (app_data.dcb_app_idtype) printf(" \t DCB_APP_IDTYPE_ETHTYPE.\n"); else printf(" \t DCB_APP_IDTYPE_PORTNUM.\n"); printf(" APP ID: 0x%0x.\n", app_data.dcb_app_id); printf(" APP PRIORITY: 0x%0x.\n", app_data.dcb_app_priority); } else { printf("GETTING APP FAILED!.\n"); } #endif /* DCB_APP_DRV_IF_SUPPORTED */ if (!read_only) { struct ieee_ets ets = { .willing = 0, .ets_cap = 0x1, .cbs = 0, .tc_tx_bw = {25, 25, 25, 25, 0, 0, 0, 0}, .tc_rx_bw = {0, 0, 0, 0, 25, 25, 25, 25}, .tc_tsa = {1, 2, 3, 4, 1, 2, 3, 4}, .prio_tc = {1, 2, 3, 4, 1, 2, 3, 4} }; struct ieee_pfc pfc = { .pfc_cap = 0xf1, .pfc_en = 0, .mbc = 0, .delay = 0x32 }; struct dcb_app app = { .selector = 0, .priority = 4, .protocol = 0x8906 }; printf("\nSETTING ETS:\n"); set_ieee(ifname, &ets, &pfc, &app); } get_ieee(ifname); err_main: close(nl_sd); return err; }
/* * Server has asked us to make a choice. * * Ask AI and return result. */ static void handle_choose(char *ptr) { player *p_ptr; char msg[1024]; int pos, type, num, num_special; int list[MAX_DECK], special[MAX_DECK]; int arg1, arg2, arg3; int i; /* Get player pointer */ p_ptr = &real_game.p[player_us]; /* Read choice log position expected */ pos = get_integer(&ptr); /* Check for further along in log than we are */ if (pos > p_ptr->choice_pos) { /* Adjust current position */ p_ptr->choice_size = p_ptr->choice_pos = pos; } /* Check for request for choice we have already made */ else if (pos < p_ptr->choice_pos) { /* XXX Do nothing */ return; } /* Read choice type */ type = get_integer(&ptr); /* Read number of items in list */ num = get_integer(&ptr); /* Loop over items in list */ for (i = 0; i < num; i++) { /* Read list item */ list[i] = get_integer(&ptr); } /* Read number of special items in list */ num_special = get_integer(&ptr); /* Loop over special items */ for (i = 0; i < num_special; i++) { /* Read special item */ special[i] = get_integer(&ptr); } /* Read extra arguments */ arg1 = get_integer(&ptr); arg2 = get_integer(&ptr); arg3 = get_integer(&ptr); /* Ask AI for decision */ ai_func.make_choice(&real_game, player_us, type, list, &num, special, &num_special, arg1, arg2, arg3); /* Start reply */ ptr = msg; /* Begin message */ start_msg(&ptr, MSG_CHOOSE); /* Put choice log position */ put_integer(p_ptr->choice_pos, &ptr); /* Copy entries from choice log */ for (i = p_ptr->choice_pos; i < p_ptr->choice_size; i++) { /* Copy entry */ put_integer(p_ptr->choice_log[i], &ptr); } /* Move current position to end of choice log */ p_ptr->choice_pos = p_ptr->choice_size; /* Finish message */ finish_msg(msg, ptr); /* Send reply */ send_msg(0, msg); }
static int get_pg(char *ifname, struct tc_config *tc, __u8 *bwg, int cmd) { struct nlmsghdr *nlh; struct dcbmsg *d; struct rtattr *class_parent, *param_parent, *rta_child; __u8 *p = (__u8 *)tc; int i, j; nlh = start_msg(RTM_GETDCB, cmd); if (NULL==nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); class_parent = add_rta(nlh, DCB_ATTR_PG_CFG, NULL, 0); param_parent = add_rta(nlh, DCB_PG_ATTR_TC_ALL, NULL, 0); rta_child = add_rta(nlh, DCB_TC_ATTR_PARAM_ALL, NULL, 0); param_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); class_parent->rta_len += NLMSG_ALIGN(param_parent->rta_len); rta_child = add_rta(nlh, DCB_PG_ATTR_BW_ID_ALL, NULL, 0); class_parent->rta_len += NLMSG_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; nlh = get_msg(); if (!nlh) return -EIO; d = (struct dcbmsg *)NLMSG_DATA(nlh); class_parent = (struct rtattr *)(((char *)d) + NLMSG_ALIGN(sizeof(struct dcbmsg))); if (d->cmd != cmd) { printf("Hmm, this is not the message we were expecting.\n"); return -EIO; } if (class_parent->rta_type != DCB_ATTR_PG_CFG) { /* Do we really want to code up an attribute parser?? */ printf("A full libnetlink (with genl and attribute support) " "would sure be nice.\n"); return -EIO; } param_parent = NLA_DATA(class_parent); class_parent = (struct rtattr *)((char *)class_parent + NLMSG_ALIGN(class_parent->rta_len)); for (i = 0; class_parent > param_parent; i++) { if (param_parent->rta_type >= DCB_PG_ATTR_TC_0 && param_parent->rta_type < DCB_PG_ATTR_TC_MAX) { rta_child = NLA_DATA(param_parent); param_parent = (struct rtattr *)((char *)param_parent + NLMSG_ALIGN(param_parent->rta_len)); for (j = 0; param_parent > rta_child; j++) { if (j == DCB_TC_ATTR_PARAM_MAX - DCB_TC_ATTR_PARAM_UNDEFINED + 1) { printf("parameter array out of " "range: %d\n", j); break; } *p = *(__u8 *)NLA_DATA(rta_child); rta_child = (struct rtattr *)((char *)rta_child + NLMSG_ALIGN(rta_child->rta_len)); p++; } if (param_parent != rta_child) { printf("param_parent and rta_child pointers " "are off\n"); } } else if (param_parent->rta_type >= DCB_PG_ATTR_BW_ID_0 && param_parent->rta_type < DCB_PG_ATTR_BW_ID_MAX) { j = param_parent->rta_type - DCB_PG_ATTR_BW_ID_0; bwg[j] = *(__u8 *)NLA_DATA(param_parent); param_parent = (struct rtattr *)((char *)param_parent + NLMSG_ALIGN(param_parent->rta_len)); } else printf("unknown param_parent type = %d\n", param_parent->rta_type); } if (class_parent != param_parent) printf("class_parent and param_parent pointers are off\n"); return 0; }