int hisi_ion_enable_iommu(struct platform_device *pdev)
{
int ret;
struct iommu_domain_capablity data;
struct device *dev = &pdev->dev;
struct hisi_iommu_domain *hisi_domain;
struct device_node *np = pdev->dev.of_node;
printk(KERN_ERR"in %s start \n",__func__);
hisi_domain = kzalloc(sizeof(*hisi_domain), GFP_KERNEL);
if (!hisi_domain) {
dbg("alloc hisi_domain object fail \n");
return -ENOMEM;
}
if (!iommu_present(dev->bus)) {
dbg("iommu not found\n");
kfree(hisi_domain);
return 0;
}
/* create iommu domain */
hisi_domain->domain = iommu_domain_alloc(dev->bus);
if (!hisi_domain->domain) {
ret = -EINVAL;
goto error;
}
iommu_attach_device(hisi_domain->domain,dev);
get_range_info(np,hisi_domain,&data);
/* align mean in this pool allocation buffer is aligned by iommu align request*/
hisi_domain->iova_pool = iova_pool_setup(data.iova_start,
data.iova_end, data.iova_align);
if (!hisi_domain->iova_pool) {
ret = -EINVAL;
goto error;
}
/* this is a global pointer */
hisi_iommu_domain_p = hisi_domain;
dbg("in %s end \n",__func__);
return 0;
error:
WARN(1, "hisi_iommu_domain_init failed!\n");
if (hisi_domain->iova_pool)
iova_pool_destory(hisi_domain->iova_pool);
if (hisi_domain->domain)
iommu_domain_free(hisi_domain->domain);
if (hisi_domain)
kfree(hisi_domain);
return ret;
}
static int get_sens(const char *dev, const char *key)
{
/* Get sensitivity */
struct iwreq req;
struct iw_range range;
char key_buffer[32];
char buffer[64];
int age;
int has_sens = 0;
int has_range = 0;
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
age = hash_age(&wireless, key);
/* reread every HASH_TTL msec only */
if (age > 0 && age <= HASH_TTL) {
return (0);
}
if (get_ifname(&req, dev) != 0) {
return (-1);
}
if (do_ioctl(sock, dev, SIOCGIWSENS, &req) >= 0) {
has_sens = 1;
}
if (get_range_info(sock, dev, &range) < 0) {
memset(&range, 0, sizeof(range));
} else {
has_range = 1;
}
if (has_range) {
if (req.u.sens.value < 0) {
qprintf(buffer, sizeof(buffer), "%d dBm", req.u.sens.value);
} else {
qprintf(buffer, sizeof(buffer), "%d/%d", req.u.sens.value, range.sensitivity);
}
} else {
qprintf(buffer, sizeof(buffer), "%d", req.u.sens.value);
}
hash_put(&wireless, key_buffer, buffer);
return (0);
}
void
ubsan_expand_si_overflow_mul_check (gimple stmt)
{
rtx res, op0, op1;
tree lhs, fn, arg0, arg1;
rtx_code_label *done_label, *do_error;
rtx target = NULL_RTX;
lhs = gimple_call_lhs (stmt);
arg0 = gimple_call_arg (stmt, 0);
arg1 = gimple_call_arg (stmt, 1);
done_label = gen_label_rtx ();
do_error = gen_label_rtx ();
do_pending_stack_adjust ();
op0 = expand_normal (arg0);
op1 = expand_normal (arg1);
machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
if (lhs)
target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
enum insn_code icode = optab_handler (mulv4_optab, mode);
if (icode != CODE_FOR_nothing)
{
struct expand_operand ops[4];
rtx_insn *last = get_last_insn ();
res = gen_reg_rtx (mode);
create_output_operand (&ops[0], res, mode);
create_input_operand (&ops[1], op0, mode);
create_input_operand (&ops[2], op1, mode);
create_fixed_operand (&ops[3], do_error);
if (maybe_expand_insn (icode, 4, ops))
{
last = get_last_insn ();
if (profile_status_for_fn (cfun) != PROFILE_ABSENT
&& JUMP_P (last)
&& any_condjump_p (last)
&& !find_reg_note (last, REG_BR_PROB, 0))
add_int_reg_note (last, REG_BR_PROB, PROB_VERY_UNLIKELY);
emit_jump (done_label);
}
else
{
delete_insns_since (last);
icode = CODE_FOR_nothing;
}
}
if (icode == CODE_FOR_nothing)
{
struct separate_ops ops;
machine_mode hmode
= mode_for_size (GET_MODE_PRECISION (mode) / 2, MODE_INT, 1);
ops.op0 = arg0;
ops.op1 = arg1;
ops.op2 = NULL_TREE;
ops.location = gimple_location (stmt);
if (GET_MODE_2XWIDER_MODE (mode) != VOIDmode
&& targetm.scalar_mode_supported_p (GET_MODE_2XWIDER_MODE (mode)))
{
machine_mode wmode = GET_MODE_2XWIDER_MODE (mode);
ops.code = WIDEN_MULT_EXPR;
ops.type
= build_nonstandard_integer_type (GET_MODE_PRECISION (wmode), 0);
res = expand_expr_real_2 (&ops, NULL_RTX, wmode, EXPAND_NORMAL);
rtx hipart = expand_shift (RSHIFT_EXPR, wmode, res,
GET_MODE_PRECISION (mode), NULL_RTX, 0);
hipart = gen_lowpart (mode, hipart);
res = gen_lowpart (mode, res);
rtx signbit = expand_shift (RSHIFT_EXPR, mode, res,
GET_MODE_PRECISION (mode) - 1,
NULL_RTX, 0);
/* RES is low half of the double width result, HIPART
the high half. There was overflow if
HIPART is different from RES < 0 ? -1 : 0. */
emit_cmp_and_jump_insns (signbit, hipart, EQ, NULL_RTX, mode,
false, done_label, PROB_VERY_LIKELY);
}
else if (hmode != BLKmode
&& 2 * GET_MODE_PRECISION (hmode) == GET_MODE_PRECISION (mode))
{
rtx_code_label *large_op0 = gen_label_rtx ();
rtx_code_label *small_op0_large_op1 = gen_label_rtx ();
rtx_code_label *one_small_one_large = gen_label_rtx ();
rtx_code_label *both_ops_large = gen_label_rtx ();
rtx_code_label *after_hipart_neg = gen_label_rtx ();
rtx_code_label *after_lopart_neg = gen_label_rtx ();
rtx_code_label *do_overflow = gen_label_rtx ();
rtx_code_label *hipart_different = gen_label_rtx ();
unsigned int hprec = GET_MODE_PRECISION (hmode);
rtx hipart0 = expand_shift (RSHIFT_EXPR, mode, op0, hprec,
NULL_RTX, 0);
hipart0 = gen_lowpart (hmode, hipart0);
rtx lopart0 = gen_lowpart (hmode, op0);
rtx signbit0 = expand_shift (RSHIFT_EXPR, hmode, lopart0, hprec - 1,
NULL_RTX, 0);
rtx hipart1 = expand_shift (RSHIFT_EXPR, mode, op1, hprec,
NULL_RTX, 0);
hipart1 = gen_lowpart (hmode, hipart1);
rtx lopart1 = gen_lowpart (hmode, op1);
rtx signbit1 = expand_shift (RSHIFT_EXPR, hmode, lopart1, hprec - 1,
NULL_RTX, 0);
res = gen_reg_rtx (mode);
/* True if op0 resp. op1 are known to be in the range of
halfstype. */
bool op0_small_p = false;
bool op1_small_p = false;
/* True if op0 resp. op1 are known to have all zeros or all ones
in the upper half of bits, but are not known to be
op{0,1}_small_p. */
bool op0_medium_p = false;
bool op1_medium_p = false;
/* -1 if op{0,1} is known to be negative, 0 if it is known to be
nonnegative, 1 if unknown. */
int op0_sign = 1;
int op1_sign = 1;
if (TREE_CODE (arg0) == SSA_NAME)
{
wide_int arg0_min, arg0_max;
if (get_range_info (arg0, &arg0_min, &arg0_max) == VR_RANGE)
{
unsigned int mprec0 = wi::min_precision (arg0_min, SIGNED);
unsigned int mprec1 = wi::min_precision (arg0_max, SIGNED);
if (mprec0 <= hprec && mprec1 <= hprec)
op0_small_p = true;
else if (mprec0 <= hprec + 1 && mprec1 <= hprec + 1)
op0_medium_p = true;
if (!wi::neg_p (arg0_min, TYPE_SIGN (TREE_TYPE (arg0))))
op0_sign = 0;
else if (wi::neg_p (arg0_max, TYPE_SIGN (TREE_TYPE (arg0))))
op0_sign = -1;
}
}
if (TREE_CODE (arg1) == SSA_NAME)
{
wide_int arg1_min, arg1_max;
if (get_range_info (arg1, &arg1_min, &arg1_max) == VR_RANGE)
{
unsigned int mprec0 = wi::min_precision (arg1_min, SIGNED);
unsigned int mprec1 = wi::min_precision (arg1_max, SIGNED);
if (mprec0 <= hprec && mprec1 <= hprec)
op1_small_p = true;
else if (mprec0 <= hprec + 1 && mprec1 <= hprec + 1)
op1_medium_p = true;
if (!wi::neg_p (arg1_min, TYPE_SIGN (TREE_TYPE (arg1))))
op1_sign = 0;
else if (wi::neg_p (arg1_max, TYPE_SIGN (TREE_TYPE (arg1))))
op1_sign = -1;
}
}
int smaller_sign = 1;
int larger_sign = 1;
if (op0_small_p)
{
smaller_sign = op0_sign;
larger_sign = op1_sign;
}
else if (op1_small_p)
{
smaller_sign = op1_sign;
larger_sign = op0_sign;
}
else if (op0_sign == op1_sign)
{
smaller_sign = op0_sign;
larger_sign = op0_sign;
}
if (!op0_small_p)
emit_cmp_and_jump_insns (signbit0, hipart0, NE, NULL_RTX, hmode,
false, large_op0, PROB_UNLIKELY);
if (!op1_small_p)
emit_cmp_and_jump_insns (signbit1, hipart1, NE, NULL_RTX, hmode,
false, small_op0_large_op1,
PROB_UNLIKELY);
/* If both op0 and op1 are sign extended from hmode to mode,
the multiplication will never overflow. We can do just one
hmode x hmode => mode widening multiplication. */
if (GET_CODE (lopart0) == SUBREG)
{
SUBREG_PROMOTED_VAR_P (lopart0) = 1;
SUBREG_PROMOTED_SET (lopart0, 0);
}
if (GET_CODE (lopart1) == SUBREG)
{
SUBREG_PROMOTED_VAR_P (lopart1) = 1;
SUBREG_PROMOTED_SET (lopart1, 0);
}
tree halfstype = build_nonstandard_integer_type (hprec, 0);
ops.op0 = make_tree (halfstype, lopart0);
ops.op1 = make_tree (halfstype, lopart1);
ops.code = WIDEN_MULT_EXPR;
ops.type = TREE_TYPE (arg0);
rtx thisres
= expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
emit_move_insn (res, thisres);
emit_jump (done_label);
emit_label (small_op0_large_op1);
/* If op0 is sign extended from hmode to mode, but op1 is not,
just swap the arguments and handle it as op1 sign extended,
op0 not. */
rtx larger = gen_reg_rtx (mode);
rtx hipart = gen_reg_rtx (hmode);
rtx lopart = gen_reg_rtx (hmode);
emit_move_insn (larger, op1);
emit_move_insn (hipart, hipart1);
emit_move_insn (lopart, lopart0);
emit_jump (one_small_one_large);
emit_label (large_op0);
if (!op1_small_p)
emit_cmp_and_jump_insns (signbit1, hipart1, NE, NULL_RTX, hmode,
false, both_ops_large, PROB_UNLIKELY);
/* If op1 is sign extended from hmode to mode, but op0 is not,
prepare larger, hipart and lopart pseudos and handle it together
with small_op0_large_op1. */
emit_move_insn (larger, op0);
emit_move_insn (hipart, hipart0);
emit_move_insn (lopart, lopart1);
emit_label (one_small_one_large);
/* lopart is the low part of the operand that is sign extended
to mode, larger is the the other operand, hipart is the
high part of larger and lopart0 and lopart1 are the low parts
of both operands.
We perform lopart0 * lopart1 and lopart * hipart widening
multiplications. */
tree halfutype = build_nonstandard_integer_type (hprec, 1);
ops.op0 = make_tree (halfutype, lopart0);
ops.op1 = make_tree (halfutype, lopart1);
rtx lo0xlo1
= expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
ops.op0 = make_tree (halfutype, lopart);
ops.op1 = make_tree (halfutype, hipart);
rtx loxhi = gen_reg_rtx (mode);
rtx tem = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
emit_move_insn (loxhi, tem);
/* if (hipart < 0) loxhi -= lopart << (bitsize / 2); */
if (larger_sign == 0)
emit_jump (after_hipart_neg);
else if (larger_sign != -1)
emit_cmp_and_jump_insns (hipart, const0_rtx, GE, NULL_RTX, hmode,
false, after_hipart_neg, PROB_EVEN);
tem = convert_modes (mode, hmode, lopart, 1);
tem = expand_shift (LSHIFT_EXPR, mode, tem, hprec, NULL_RTX, 1);
tem = expand_simple_binop (mode, MINUS, loxhi, tem, NULL_RTX,
1, OPTAB_DIRECT);
emit_move_insn (loxhi, tem);
emit_label (after_hipart_neg);
/* if (lopart < 0) loxhi -= larger; */
if (smaller_sign == 0)
emit_jump (after_lopart_neg);
else if (smaller_sign != -1)
emit_cmp_and_jump_insns (lopart, const0_rtx, GE, NULL_RTX, hmode,
false, after_lopart_neg, PROB_EVEN);
tem = expand_simple_binop (mode, MINUS, loxhi, larger, NULL_RTX,
1, OPTAB_DIRECT);
emit_move_insn (loxhi, tem);
emit_label (after_lopart_neg);
/* loxhi += (uns) lo0xlo1 >> (bitsize / 2); */
tem = expand_shift (RSHIFT_EXPR, mode, lo0xlo1, hprec, NULL_RTX, 1);
tem = expand_simple_binop (mode, PLUS, loxhi, tem, NULL_RTX,
1, OPTAB_DIRECT);
emit_move_insn (loxhi, tem);
/* if (loxhi >> (bitsize / 2)
== (hmode) loxhi >> (bitsize / 2 - 1)) */
rtx hipartloxhi = expand_shift (RSHIFT_EXPR, mode, loxhi, hprec,
NULL_RTX, 0);
hipartloxhi = gen_lowpart (hmode, hipartloxhi);
rtx lopartloxhi = gen_lowpart (hmode, loxhi);
rtx signbitloxhi = expand_shift (RSHIFT_EXPR, hmode, lopartloxhi,
hprec - 1, NULL_RTX, 0);
emit_cmp_and_jump_insns (signbitloxhi, hipartloxhi, NE, NULL_RTX,
hmode, false, do_overflow,
PROB_VERY_UNLIKELY);
/* res = (loxhi << (bitsize / 2)) | (hmode) lo0xlo1; */
rtx loxhishifted = expand_shift (LSHIFT_EXPR, mode, loxhi, hprec,
NULL_RTX, 1);
tem = convert_modes (mode, hmode, gen_lowpart (hmode, lo0xlo1), 1);
tem = expand_simple_binop (mode, IOR, loxhishifted, tem, res,
1, OPTAB_DIRECT);
if (tem != res)
emit_move_insn (res, tem);
emit_jump (done_label);
emit_label (both_ops_large);
/* If both operands are large (not sign extended from hmode),
then perform the full multiplication which will be the result
of the operation. The only cases which don't overflow are
some cases where both hipart0 and highpart1 are 0 or -1. */
ops.code = MULT_EXPR;
ops.op0 = make_tree (TREE_TYPE (arg0), op0);
ops.op1 = make_tree (TREE_TYPE (arg0), op1);
tem = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
emit_move_insn (res, tem);
if (!op0_medium_p)
{
tem = expand_simple_binop (hmode, PLUS, hipart0, const1_rtx,
NULL_RTX, 1, OPTAB_DIRECT);
emit_cmp_and_jump_insns (tem, const1_rtx, GTU, NULL_RTX, hmode,
true, do_error, PROB_VERY_UNLIKELY);
}
if (!op1_medium_p)
{
tem = expand_simple_binop (hmode, PLUS, hipart1, const1_rtx,
NULL_RTX, 1, OPTAB_DIRECT);
emit_cmp_and_jump_insns (tem, const1_rtx, GTU, NULL_RTX, hmode,
true, do_error, PROB_VERY_UNLIKELY);
}
/* At this point hipart{0,1} are both in [-1, 0]. If they are the
same, overflow happened if res is negative, if they are different,
overflow happened if res is positive. */
if (op0_sign != 1 && op1_sign != 1 && op0_sign != op1_sign)
emit_jump (hipart_different);
else if (op0_sign == 1 || op1_sign == 1)
emit_cmp_and_jump_insns (hipart0, hipart1, NE, NULL_RTX, hmode,
true, hipart_different, PROB_EVEN);
emit_cmp_and_jump_insns (res, const0_rtx, LT, NULL_RTX, mode, false,
do_error, PROB_VERY_UNLIKELY);
emit_jump (done_label);
emit_label (hipart_different);
emit_cmp_and_jump_insns (res, const0_rtx, GE, NULL_RTX, mode, false,
do_error, PROB_VERY_UNLIKELY);
emit_jump (done_label);
emit_label (do_overflow);
/* Overflow, do full multiplication and fallthru into do_error. */
ops.op0 = make_tree (TREE_TYPE (arg0), op0);
ops.op1 = make_tree (TREE_TYPE (arg0), op1);
tem = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
emit_move_insn (res, tem);
}
else
{
ops.code = MULT_EXPR;
ops.type = TREE_TYPE (arg0);
res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
emit_jump (done_label);
}
}
emit_label (do_error);
/* Expand the ubsan builtin call. */
push_temp_slots ();
fn = ubsan_build_overflow_builtin (MULT_EXPR, gimple_location (stmt),
TREE_TYPE (arg0), arg0, arg1);
expand_normal (fn);
pop_temp_slots ();
do_pending_stack_adjust ();
/* We're done. */
emit_label (done_label);
if (lhs)
emit_move_insn (target, res);
}
void
ubsan_expand_si_overflow_addsub_check (tree_code code, gimple stmt)
{
rtx res, op0, op1;
tree lhs, fn, arg0, arg1;
rtx_code_label *done_label, *do_error;
rtx target = NULL_RTX;
lhs = gimple_call_lhs (stmt);
arg0 = gimple_call_arg (stmt, 0);
arg1 = gimple_call_arg (stmt, 1);
done_label = gen_label_rtx ();
do_error = gen_label_rtx ();
do_pending_stack_adjust ();
op0 = expand_normal (arg0);
op1 = expand_normal (arg1);
machine_mode mode = TYPE_MODE (TREE_TYPE (arg0));
if (lhs)
target = expand_expr (lhs, NULL_RTX, VOIDmode, EXPAND_WRITE);
enum insn_code icode
= optab_handler (code == PLUS_EXPR ? addv4_optab : subv4_optab, mode);
if (icode != CODE_FOR_nothing)
{
struct expand_operand ops[4];
rtx_insn *last = get_last_insn ();
res = gen_reg_rtx (mode);
create_output_operand (&ops[0], res, mode);
create_input_operand (&ops[1], op0, mode);
create_input_operand (&ops[2], op1, mode);
create_fixed_operand (&ops[3], do_error);
if (maybe_expand_insn (icode, 4, ops))
{
last = get_last_insn ();
if (profile_status_for_fn (cfun) != PROFILE_ABSENT
&& JUMP_P (last)
&& any_condjump_p (last)
&& !find_reg_note (last, REG_BR_PROB, 0))
add_int_reg_note (last, REG_BR_PROB, PROB_VERY_UNLIKELY);
emit_jump (done_label);
}
else
{
delete_insns_since (last);
icode = CODE_FOR_nothing;
}
}
if (icode == CODE_FOR_nothing)
{
rtx_code_label *sub_check = gen_label_rtx ();
int pos_neg = 3;
/* Compute the operation. On RTL level, the addition is always
unsigned. */
res = expand_binop (mode, code == PLUS_EXPR ? add_optab : sub_optab,
op0, op1, NULL_RTX, false, OPTAB_LIB_WIDEN);
/* If we can prove one of the arguments (for MINUS_EXPR only
the second operand, as subtraction is not commutative) is always
non-negative or always negative, we can do just one comparison
and conditional jump instead of 2 at runtime, 3 present in the
emitted code. If one of the arguments is CONST_INT, all we
need is to make sure it is op1, then the first
emit_cmp_and_jump_insns will be just folded. Otherwise try
to use range info if available. */
if (code == PLUS_EXPR && CONST_INT_P (op0))
{
rtx tem = op0;
op0 = op1;
op1 = tem;
}
else if (CONST_INT_P (op1))
;
else if (code == PLUS_EXPR && TREE_CODE (arg0) == SSA_NAME)
{
wide_int arg0_min, arg0_max;
if (get_range_info (arg0, &arg0_min, &arg0_max) == VR_RANGE)
{
if (!wi::neg_p (arg0_min, TYPE_SIGN (TREE_TYPE (arg0))))
pos_neg = 1;
else if (wi::neg_p (arg0_max, TYPE_SIGN (TREE_TYPE (arg0))))
pos_neg = 2;
}
if (pos_neg != 3)
{
rtx tem = op0;
op0 = op1;
op1 = tem;
}
}
if (pos_neg == 3 && !CONST_INT_P (op1) && TREE_CODE (arg1) == SSA_NAME)
{
wide_int arg1_min, arg1_max;
if (get_range_info (arg1, &arg1_min, &arg1_max) == VR_RANGE)
{
if (!wi::neg_p (arg1_min, TYPE_SIGN (TREE_TYPE (arg1))))
pos_neg = 1;
else if (wi::neg_p (arg1_max, TYPE_SIGN (TREE_TYPE (arg1))))
pos_neg = 2;
}
}
/* If the op1 is negative, we have to use a different check. */
if (pos_neg == 3)
emit_cmp_and_jump_insns (op1, const0_rtx, LT, NULL_RTX, mode,
false, sub_check, PROB_EVEN);
/* Compare the result of the operation with one of the operands. */
if (pos_neg & 1)
emit_cmp_and_jump_insns (res, op0, code == PLUS_EXPR ? GE : LE,
NULL_RTX, mode, false, done_label,
PROB_VERY_LIKELY);
/* If we get here, we have to print the error. */
if (pos_neg == 3)
{
emit_jump (do_error);
emit_label (sub_check);
}
/* We have k = a + b for b < 0 here. k <= a must hold. */
if (pos_neg & 2)
emit_cmp_and_jump_insns (res, op0, code == PLUS_EXPR ? LE : GE,
NULL_RTX, mode, false, done_label,
PROB_VERY_LIKELY);
}
emit_label (do_error);
/* Expand the ubsan builtin call. */
push_temp_slots ();
fn = ubsan_build_overflow_builtin (code, gimple_location (stmt),
TREE_TYPE (arg0), arg0, arg1);
expand_normal (fn);
pop_temp_slots ();
do_pending_stack_adjust ();
/* We're done. */
emit_label (done_label);
if (lhs)
emit_move_insn (target, res);
}
void
tree_to_aff_combination (tree expr, tree type, aff_tree *comb)
{
aff_tree tmp;
enum tree_code code;
tree cst, core, toffset;
poly_int64 bitpos, bitsize, bytepos;
machine_mode mode;
int unsignedp, reversep, volatilep;
STRIP_NOPS (expr);
code = TREE_CODE (expr);
switch (code)
{
case POINTER_PLUS_EXPR:
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp);
aff_combination_add (comb, &tmp);
return;
case PLUS_EXPR:
case MINUS_EXPR:
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
tree_to_aff_combination (TREE_OPERAND (expr, 1), type, &tmp);
if (code == MINUS_EXPR)
aff_combination_scale (&tmp, -1);
aff_combination_add (comb, &tmp);
return;
case MULT_EXPR:
cst = TREE_OPERAND (expr, 1);
if (TREE_CODE (cst) != INTEGER_CST)
break;
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
aff_combination_scale (comb, wi::to_widest (cst));
return;
case NEGATE_EXPR:
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
aff_combination_scale (comb, -1);
return;
case BIT_NOT_EXPR:
/* ~x = -x - 1 */
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
aff_combination_scale (comb, -1);
aff_combination_add_cst (comb, -1);
return;
case ADDR_EXPR:
/* Handle &MEM[ptr + CST] which is equivalent to POINTER_PLUS_EXPR. */
if (TREE_CODE (TREE_OPERAND (expr, 0)) == MEM_REF)
{
expr = TREE_OPERAND (expr, 0);
tree_to_aff_combination (TREE_OPERAND (expr, 0), type, comb);
tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp);
aff_combination_add (comb, &tmp);
return;
}
core = get_inner_reference (TREE_OPERAND (expr, 0), &bitsize, &bitpos,
&toffset, &mode, &unsignedp, &reversep,
&volatilep);
if (!multiple_p (bitpos, BITS_PER_UNIT, &bytepos))
break;
aff_combination_const (comb, type, bytepos);
if (TREE_CODE (core) == MEM_REF)
{
tree mem_offset = TREE_OPERAND (core, 1);
aff_combination_add_cst (comb, wi::to_poly_widest (mem_offset));
core = TREE_OPERAND (core, 0);
}
else
core = build_fold_addr_expr (core);
if (TREE_CODE (core) == ADDR_EXPR)
aff_combination_add_elt (comb, core, 1);
else
{
tree_to_aff_combination (core, type, &tmp);
aff_combination_add (comb, &tmp);
}
if (toffset)
{
tree_to_aff_combination (toffset, type, &tmp);
aff_combination_add (comb, &tmp);
}
return;
case MEM_REF:
if (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR)
tree_to_aff_combination (TREE_OPERAND (TREE_OPERAND (expr, 0), 0),
type, comb);
else if (integer_zerop (TREE_OPERAND (expr, 1)))
{
aff_combination_elt (comb, type, expr);
return;
}
else
aff_combination_elt (comb, type,
build2 (MEM_REF, TREE_TYPE (expr),
TREE_OPERAND (expr, 0),
build_int_cst
(TREE_TYPE (TREE_OPERAND (expr, 1)), 0)));
tree_to_aff_combination (TREE_OPERAND (expr, 1), sizetype, &tmp);
aff_combination_add (comb, &tmp);
return;
CASE_CONVERT:
{
tree otype = TREE_TYPE (expr);
tree inner = TREE_OPERAND (expr, 0);
tree itype = TREE_TYPE (inner);
enum tree_code icode = TREE_CODE (inner);
/* In principle this is a valid folding, but it isn't necessarily
an optimization, so do it here and not in fold_unary. */
if ((icode == PLUS_EXPR || icode == MINUS_EXPR || icode == MULT_EXPR)
&& TREE_CODE (itype) == INTEGER_TYPE
&& TREE_CODE (otype) == INTEGER_TYPE
&& TYPE_PRECISION (otype) > TYPE_PRECISION (itype))
{
tree op0 = TREE_OPERAND (inner, 0), op1 = TREE_OPERAND (inner, 1);
/* If inner type has undefined overflow behavior, fold conversion
for below two cases:
(T1)(X *+- CST) -> (T1)X *+- (T1)CST
(T1)(X + X) -> (T1)X + (T1)X. */
if (TYPE_OVERFLOW_UNDEFINED (itype)
&& (TREE_CODE (op1) == INTEGER_CST
|| (icode == PLUS_EXPR && operand_equal_p (op0, op1, 0))))
{
op0 = fold_convert (otype, op0);
op1 = fold_convert (otype, op1);
expr = fold_build2 (icode, otype, op0, op1);
tree_to_aff_combination (expr, type, comb);
return;
}
wide_int minv, maxv;
/* If inner type has wrapping overflow behavior, fold conversion
for below case:
(T1)(X - CST) -> (T1)X - (T1)CST
if X - CST doesn't overflow by range information. Also handle
(T1)(X + CST) as (T1)(X - (-CST)). */
if (TYPE_UNSIGNED (itype)
&& TYPE_OVERFLOW_WRAPS (itype)
&& TREE_CODE (op0) == SSA_NAME
&& TREE_CODE (op1) == INTEGER_CST
&& icode != MULT_EXPR
&& get_range_info (op0, &minv, &maxv) == VR_RANGE)
{
if (icode == PLUS_EXPR)
op1 = wide_int_to_tree (itype, -wi::to_wide (op1));
if (wi::geu_p (minv, wi::to_wide (op1)))
{
op0 = fold_convert (otype, op0);
op1 = fold_convert (otype, op1);
expr = fold_build2 (MINUS_EXPR, otype, op0, op1);
tree_to_aff_combination (expr, type, comb);
return;
}
}
}
}
break;
default:
{
if (poly_int_tree_p (expr))
{
aff_combination_const (comb, type, wi::to_poly_widest (expr));
return;
}
break;
}
}
aff_combination_elt (comb, type, expr);
}
static int get_stats(const char *dev, const char *key)
{
struct iw_statistics stats;
struct iwreq req;
char qprintf_buffer[1024];
char key_buffer[32];
int age;
struct iw_range range;
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, key);
age = hash_age(&wireless, key);
/* reread every HASH_TTL msec only */
if (age > 0 && age <= HASH_TTL) {
return (0);
}
if (get_ifname(&req, dev) != 0) {
return (-1);
}
req.u.data.pointer = (caddr_t) & stats;
req.u.data.length = sizeof(stats);
req.u.data.flags = 1; /* Clear updated flag */
if (do_ioctl(sock, dev, SIOCGIWSTATS, &req) < 0) {
ioctl_error(__LINE__);
return -1;
}
if (get_range_info(sock, dev, &range) < 0)
memset(&range, 0, sizeof(range));
if (stats.qual.level > range.max_qual.level) {
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.level - 0x100);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d", stats.qual.noise - 0x100);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
hash_put(&wireless, key_buffer, qprintf_buffer);
} else {
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.level, range.max_qual.level);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_LEVEL);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.noise, range.max_qual.noise);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_NOISE);
hash_put(&wireless, key_buffer, qprintf_buffer);
qprintf(qprintf_buffer, sizeof(qprintf_buffer), "%d/%d", stats.qual.qual, range.max_qual.qual);
qprintf(key_buffer, sizeof(key_buffer), "%s.%s", dev, KEY_QUALITY);
hash_put(&wireless, key_buffer, qprintf_buffer);
}
return 0;
}
/*
* Set the wireless options requested on command line
* This function is too long and probably should be split,
* because it look like the perfect definition of spaghetti code,
* but I'm way to lazy
*/
static int
set_info(int skfd, /* The socket */
char * args[], /* Command line args */
int count, /* Args count */
char * ifname) /* Dev name */
{
struct iwreq wrq;
int i;
/* Set dev name */
strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
/* if nothing after the device name */
if(count<1)
iw_usage();
/* The other args on the line specify options to be set... */
for(i = 0; i < count; i++)
{
/* ---------- Set network ID ---------- */
if((!strcasecmp(args[i], "nwid")) ||
(!strcasecmp(args[i], "domain")))
{
i++;
if(i >= count)
iw_usage();
if((!strcasecmp(args[i], "off")) ||
(!strcasecmp(args[i], "any")))
wrq.u.nwid.disabled = 1;
else
if(!strcasecmp(args[i], "on"))
{
/* Get old nwid */
if(ioctl(skfd, SIOCGIWNWID, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWNWID: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.nwid.disabled = 0;
}
else
if(sscanf(args[i], "%lX", (unsigned long *) &(wrq.u.nwid.value))
!= 1)
iw_usage();
else
wrq.u.nwid.disabled = 0;
wrq.u.nwid.fixed = 1;
if(ioctl(skfd, SIOCSIWNWID, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWNWID: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set frequency / channel ---------- */
if((!strncmp(args[i], "freq", 4)) ||
(!strcmp(args[i], "channel")))
{
double freq;
if(++i >= count)
iw_usage();
if(sscanf(args[i], "%lg", &(freq)) != 1)
iw_usage();
if(index(args[i], 'G')) freq *= GIGA;
if(index(args[i], 'M')) freq *= MEGA;
if(index(args[i], 'k')) freq *= KILO;
float2freq(freq, &(wrq.u.freq));
if(ioctl(skfd, SIOCSIWFREQ, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWFREQ: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set sensitivity ---------- */
if(!strncmp(args[i], "sens", 4))
{
if(++i >= count)
iw_usage();
if(sscanf(args[i], "%d", &(wrq.u.sens.value)) != 1)
iw_usage();
if(ioctl(skfd, SIOCSIWSENS, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWSENS: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set encryption stuff ---------- */
if((!strncmp(args[i], "enc", 3)) ||
(!strcmp(args[i], "key")))
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
if(++i >= count)
iw_usage();
if(!strcasecmp(args[i], "on"))
{
/* Get old encryption information */
wrq.u.data.pointer = (caddr_t) key;
wrq.u.data.length = 0;
wrq.u.data.flags = 0;
if(ioctl(skfd, SIOCGIWENCODE, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWENCODE: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.data.flags &= ~IW_ENCODE_DISABLED; /* Enable */
}
else
{
char * buff;
char * p;
int temp;
int k = 0;
int gotone = 1;
wrq.u.data.pointer = (caddr_t) NULL;
wrq.u.data.flags = 0;
wrq.u.data.length = 0;
/* -- Check for the key -- */
if(!strncmp(args[i], "s:", 2))
{
/* First case : as an ASCII string */
wrq.u.data.length = strlen(args[i] + 2);
if(wrq.u.data.length > IW_ENCODING_TOKEN_MAX)
wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
strncpy(key, args[i] + 2, wrq.u.data.length);
wrq.u.data.pointer = (caddr_t) key;
++i;
gotone = 1;
}
else
{
/* Second case : has hexadecimal digits */
p = buff = malloc(strlen(args[i]) + 1);
strcpy(buff, args[i]);
p = strtok(buff, "-:;.,");
while(p != (char *) NULL)
{
if(sscanf(p, "%2X", &temp) != 1)
{
gotone = 0;
break;
}
key[k++] = (unsigned char) (temp & 0xFF);
if(strlen(p) > 2) /* Token not finished yet */
p += 2;
else
p = strtok((char *) NULL, "-:;.,");
}
free(buff);
if(gotone)
{
++i;
wrq.u.data.length = k;
wrq.u.data.pointer = (caddr_t) key;
}
}
/* -- Check for token index -- */
if((i < count) &&
(sscanf(args[i], "[%d]", &temp) == 1) &&
(temp > 0) && (temp < IW_ENCODE_INDEX))
{
wrq.u.encoding.flags |= temp;
++i;
gotone = 1;
}
/* -- Check the various flags -- */
if(i < count)
{
if(!strcasecmp(args[i], "off"))
wrq.u.data.flags |= IW_ENCODE_DISABLED;
if(!strcasecmp(args[i], "open"))
wrq.u.data.flags |= IW_ENCODE_OPEN;
if(!strncasecmp(args[i], "restricted", 5))
wrq.u.data.flags |= IW_ENCODE_RESTRICTED;
if(wrq.u.data.flags & IW_ENCODE_FLAGS)
{
++i;
gotone = 1;
}
}
if(!gotone)
iw_usage();
--i;
}
if(ioctl(skfd, SIOCSIWENCODE, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWENCODE(%d): %s\n",
errno, strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set ESSID ---------- */
if(!strcasecmp(args[i], "essid"))
{
char essid[IW_ESSID_MAX_SIZE + 1];
i++;
if(i >= count)
iw_usage();
if((!strcasecmp(args[i], "off")) ||
(!strcasecmp(args[i], "any")))
{
wrq.u.essid.flags = 0;
essid[0] = '\0';
}
else
if(!strcasecmp(args[i], "on"))
{
/* Get old essid */
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = 0;
wrq.u.essid.flags = 0;
if(ioctl(skfd, SIOCGIWESSID, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWESSID: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.essid.flags = 1;
}
else
if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
{
fprintf(stderr, "ESSID too long (max %d): ``%s''\n",
IW_ESSID_MAX_SIZE, args[i]);
iw_usage();
}
else
{
int temp;
wrq.u.essid.flags = 1;
strcpy(essid, args[i]);
/* Check for ESSID index */
if(((i+1) < count) &&
(sscanf(args[i+1], "[%d]", &temp) == 1) &&
(temp > 0) && (temp < IW_ENCODE_INDEX))
{
wrq.u.essid.flags = temp;
++i;
}
}
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = strlen(essid) + 1;
if(ioctl(skfd, SIOCSIWESSID, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWESSID: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set AP address ---------- */
if(!strcasecmp(args[i], "ap"))
{
if(++i >= count)
iw_usage();
/* Check if we have valid address types */
if(check_addr_type(skfd, ifname) < 0)
{
fprintf(stderr, "%-8.8s Interface doesn't support MAC & IP addresses\n", ifname);
return(-1);
}
/* Get the address */
if(in_addr(skfd, ifname, args[i++], &(wrq.u.ap_addr)) < 0)
iw_usage();
if(ioctl(skfd, SIOCSIWAP, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWAP: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set NickName ---------- */
if(!strncmp(args[i], "nick", 4))
{
i++;
if(i >= count)
iw_usage();
if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
{
fprintf(stderr, "Name too long (max %d) : ``%s''\n",
IW_ESSID_MAX_SIZE, args[i]);
iw_usage();
}
wrq.u.essid.pointer = (caddr_t) args[i];
wrq.u.essid.length = strlen(args[i]) + 1;
if(ioctl(skfd, SIOCSIWNICKN, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWNICKN: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set Bit-Rate ---------- */
if((!strncmp(args[i], "bit", 3)) ||
(!strcmp(args[i], "rate")))
{
if(++i >= count)
iw_usage();
if(!strcasecmp(args[i], "auto"))
{
wrq.u.bitrate.value = -1;
wrq.u.bitrate.fixed = 0;
}
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old bitrate */
if(ioctl(skfd, SIOCGIWRATE, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWRATE: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.bitrate.fixed = 1;
}
else /* Should be a numeric value */
{
double brate;
if(sscanf(args[i], "%lg", &(brate)) != 1)
iw_usage();
if(index(args[i], 'G')) brate *= GIGA;
if(index(args[i], 'M')) brate *= MEGA;
if(index(args[i], 'k')) brate *= KILO;
wrq.u.bitrate.value = (long) brate;
wrq.u.bitrate.fixed = 1;
/* Check for an additional argument */
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "auto")))
{
wrq.u.bitrate.fixed = 0;
++i;
}
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "fixed")))
{
wrq.u.bitrate.fixed = 1;
++i;
}
}
}
if(ioctl(skfd, SIOCSIWRATE, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWRATE: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set RTS threshold ---------- */
if(!strncasecmp(args[i], "rts", 3))
{
i++;
if(i >= count)
iw_usage();
wrq.u.rts.value = -1;
wrq.u.rts.fixed = 1;
wrq.u.rts.disabled = 0;
if(!strcasecmp(args[i], "off"))
wrq.u.rts.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.rts.fixed = 0;
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old RTS threshold */
if(ioctl(skfd, SIOCGIWRTS, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWRTS: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.rts.fixed = 1;
}
else /* Should be a numeric value */
if(sscanf(args[i], "%ld", (unsigned long *) &(wrq.u.rts.value))
!= 1)
iw_usage();
}
if(ioctl(skfd, SIOCSIWRTS, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWRTS: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set fragmentation threshold ---------- */
if(!strncmp(args[i], "frag", 4))
{
i++;
if(i >= count)
iw_usage();
wrq.u.frag.value = -1;
wrq.u.frag.fixed = 1;
wrq.u.frag.disabled = 0;
if(!strcasecmp(args[i], "off"))
wrq.u.frag.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.frag.fixed = 0;
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old fragmentation threshold */
if(ioctl(skfd, SIOCGIWFRAG, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWFRAG: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.frag.fixed = 1;
}
else /* Should be a numeric value */
if(sscanf(args[i], "%ld", (unsigned long *) &(wrq.u.frag.value))
!= 1)
iw_usage();
}
if(ioctl(skfd, SIOCSIWFRAG, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWFRAG: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set operation mode ---------- */
if(!strcmp(args[i], "mode"))
{
int k;
i++;
if(i >= count)
iw_usage();
if(sscanf(args[i], "%d", &k) != 1)
{
k = 0;
while(k < 6 && strncasecmp(args[i], operation_mode[k], 3))
k++;
}
if((k > 5) || (k < 0))
iw_usage();
wrq.u.mode = k;
if(ioctl(skfd, SIOCSIWMODE, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWMODE: %s\n", strerror(errno));
return(-1);
}
continue;
}
/* ---------- Set Power Management ---------- */
if(!strncmp(args[i], "power", 3))
{
if(++i >= count)
iw_usage();
if(!strcasecmp(args[i], "off"))
wrq.u.power.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "on"))
{
/* Get old Power info */
if(ioctl(skfd, SIOCGIWPOWER, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWPOWER: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.power.disabled = 0;
}
else
{
double temp;
int gotone = 0;
/* Default - nope */
wrq.u.power.flags = IW_POWER_ON;
wrq.u.power.disabled = 0;
/* Check value modifier */
if(!strcasecmp(args[i], "min"))
{
wrq.u.power.flags |= IW_POWER_MIN;
if(++i >= count)
iw_usage();
}
else
if(!strcasecmp(args[i], "max"))
{
wrq.u.power.flags |= IW_POWER_MAX;
if(++i >= count)
iw_usage();
}
/* Check value type */
if(!strcasecmp(args[i], "period"))
{
wrq.u.power.flags |= IW_POWER_PERIOD;
if(++i >= count)
iw_usage();
}
else
if(!strcasecmp(args[i], "timeout"))
{
wrq.u.power.flags |= IW_POWER_TIMEOUT;
if(++i >= count)
iw_usage();
}
/* Is there any value to grab ? */
if(sscanf(args[i], "%lg", &(temp)) == 1)
{
temp *= MEGA; /* default = s */
if(index(args[i], 'u')) temp /= MEGA;
if(index(args[i], 'm')) temp /= KILO;
wrq.u.power.value = (long) temp;
if((wrq.u.power.flags & IW_POWER_TYPE) == 0)
wrq.u.power.flags |= IW_POWER_PERIOD;
++i;
gotone = 1;
}
/* Now, check the mode */
if(i < count)
{
if(!strcasecmp(args[i], "all"))
wrq.u.power.flags |= IW_POWER_ALL_R;
if(!strncasecmp(args[i], "unicast", 4))
wrq.u.power.flags |= IW_POWER_UNICAST_R;
if(!strncasecmp(args[i], "multicast", 5))
wrq.u.power.flags |= IW_POWER_MULTICAST_R;
if(!strncasecmp(args[i], "force", 5))
wrq.u.power.flags |= IW_POWER_FORCE_S;
if(!strcasecmp(args[i], "repeat"))
wrq.u.power.flags |= IW_POWER_REPEATER;
if(wrq.u.power.flags & IW_POWER_MODE)
{
++i;
gotone = 1;
}
}
if(!gotone)
iw_usage();
--i;
}
if(ioctl(skfd, SIOCSIWPOWER, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWPOWER(%d): %s\n",
errno, strerror(errno));
return(-1);
}
continue;
}
#if WIRELESS_EXT > 9
/* ---------- Set Transmit-Power ---------- */
if(!strncmp(args[i], "txpower", 3))
{
struct iw_range range;
if(++i >= count)
iw_usage();
/* Extract range info */
if(get_range_info(skfd, ifname, &range) < 0)
memset(&range, 0, sizeof(range));
/* Prepare the request */
strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
wrq.u.txpower.value = -1;
wrq.u.txpower.fixed = 1;
wrq.u.txpower.disabled = 0;
wrq.u.data.flags = IW_TXPOW_DBM;
if(!strcasecmp(args[i], "off"))
wrq.u.txpower.disabled = 1; /* i.e. turn radio off */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.txpower.fixed = 0; /* i.e. use power control */
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old tx-power */
if(ioctl(skfd, SIOCGIWTXPOW, &wrq) < 0)
{
fprintf(stderr, "SIOCGIWTXPOW: %s\n", strerror(errno));
return(-1);
}
strcpy(wrq.ifr_name, ifname);
wrq.u.txpower.fixed = 1;
}
else /* Should be a numeric value */
{
int power;
int ismwatt = 0;
/* Get the value */
if(sscanf(args[i], "%ld",
(unsigned long *) &(power)) != 1)
iw_usage();
/* Check if milliwatt */
ismwatt = (index(args[i], 'm') != NULL);
/* Convert */
if(!ismwatt && (range.txpower_capa & IW_TXPOW_MWATT))
{
power = dbm2mwatt(power);
wrq.u.data.flags = IW_TXPOW_MWATT;
}
if(ismwatt && !(range.txpower_capa & IW_TXPOW_MWATT))
power = mwatt2dbm(power);
wrq.u.bitrate.value = power;
/* Check for an additional argument */
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "auto")))
{
wrq.u.txpower.fixed = 0;
++i;
}
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "fixed")))
{
wrq.u.txpower.fixed = 1;
++i;
}
}
}
if(ioctl(skfd, SIOCSIWTXPOW, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWTXPOW: %s\n", strerror(errno));
return(-1);
}
continue;
}
#endif
#if WIRELESS_EXT > 10
/* ---------- Set Power Management ---------- */
if(!strncmp(args[i], "retry", 3))
{
double temp;
int gotone = 0;
if(++i >= count)
iw_usage();
/* Default - nope */
wrq.u.retry.flags = IW_RETRY_LIMIT;
wrq.u.retry.disabled = 0;
/* Check value modifier */
if(!strcasecmp(args[i], "min"))
{
wrq.u.retry.flags |= IW_RETRY_MIN;
if(++i >= count)
iw_usage();
}
else
if(!strcasecmp(args[i], "max"))
{
wrq.u.retry.flags |= IW_RETRY_MAX;
if(++i >= count)
iw_usage();
}
/* Check value type */
if(!strcasecmp(args[i], "limit"))
{
wrq.u.retry.flags |= IW_RETRY_LIMIT;
if(++i >= count)
iw_usage();
}
else
if(!strncasecmp(args[i], "lifetime", 4))
{
wrq.u.retry.flags |= IW_RETRY_LIFETIME;
if(++i >= count)
iw_usage();
}
/* Is there any value to grab ? */
if(sscanf(args[i], "%lg", &(temp)) == 1)
{
/* Limit is absolute, on the other hand lifetime is seconds */
if(!(wrq.u.retry.flags & IW_RETRY_LIMIT))
{
/* Normalise lifetime */
temp *= MEGA; /* default = s */
if(index(args[i], 'u')) temp /= MEGA;
if(index(args[i], 'm')) temp /= KILO;
}
wrq.u.retry.value = (long) temp;
++i;
gotone = 1;
}
if(!gotone)
iw_usage();
--i;
if(ioctl(skfd, SIOCSIWRETRY, &wrq) < 0)
{
fprintf(stderr, "SIOCSIWRETRY(%d): %s\n",
errno, strerror(errno));
return(-1);
}
continue;
}
#endif /* WIRELESS_EXT > 10 */
/* ---------- Other ---------- */
/* Here we have an unrecognised arg... */
fprintf(stderr, "Invalid argument : %s\n", args[i]);
iw_usage();
return(-1);
} /* for(index ... */
return(0);
}
/*
* Get wireless informations & config from the device driver
* We will call all the classical wireless ioctl on the driver through
* the socket to know what is supported and to get the settings...
*/
static int
get_info(int skfd,
char * ifname,
struct wireless_info * info)
{
struct iwreq wrq;
memset((char *) info, 0, sizeof(struct wireless_info));
/* Get wireless name */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWNAME, &wrq) < 0)
/* If no wireless name : no wireless extensions */
return(-1);
else
strcpy(info->name, wrq.u.name);
/* Get ranges */
if(get_range_info(skfd, ifname, &(info->range)) >= 0)
info->has_range = 1;
/* Get network ID */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWNWID, &wrq) >= 0)
{
info->has_nwid = 1;
memcpy(&(info->nwid), &(wrq.u.nwid), sizeof(iwparam));
}
/* Get frequency / channel */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWFREQ, &wrq) >= 0)
{
info->has_freq = 1;
info->freq = freq2float(&(wrq.u.freq));
}
/* Get sensitivity */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWSENS, &wrq) >= 0)
{
info->has_sens = 1;
memcpy(&(info->sens), &(wrq.u.sens), sizeof(iwparam));
}
/* Get encryption information */
strcpy(wrq.ifr_name, ifname);
wrq.u.data.pointer = (caddr_t) info->key;
wrq.u.data.length = 0;
wrq.u.data.flags = 0;
if(ioctl(skfd, SIOCGIWENCODE, &wrq) >= 0)
{
info->has_key = 1;
info->key_size = wrq.u.data.length;
info->key_flags = wrq.u.data.flags;
}
/* Get ESSID */
strcpy(wrq.ifr_name, ifname);
wrq.u.essid.pointer = (caddr_t) info->essid;
wrq.u.essid.length = 0;
wrq.u.essid.flags = 0;
if(ioctl(skfd, SIOCGIWESSID, &wrq) >= 0)
{
info->has_essid = 1;
info->essid_on = wrq.u.data.flags;
}
/* Get AP address */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWAP, &wrq) >= 0)
{
info->has_ap_addr = 1;
memcpy(&(info->ap_addr), &(wrq.u.ap_addr), sizeof (sockaddr));
}
/* Get NickName */
strcpy(wrq.ifr_name, ifname);
wrq.u.essid.pointer = (caddr_t) info->nickname;
wrq.u.essid.length = 0;
wrq.u.essid.flags = 0;
if(ioctl(skfd, SIOCGIWNICKN, &wrq) >= 0)
if(wrq.u.data.length > 1)
info->has_nickname = 1;
/* Get bit rate */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWRATE, &wrq) >= 0)
{
info->has_bitrate = 1;
memcpy(&(info->bitrate), &(wrq.u.bitrate), sizeof(iwparam));
}
/* Get RTS threshold */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWRTS, &wrq) >= 0)
{
info->has_rts = 1;
memcpy(&(info->rts), &(wrq.u.rts), sizeof(iwparam));
}
/* Get fragmentation threshold */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWFRAG, &wrq) >= 0)
{
info->has_frag = 1;
memcpy(&(info->frag), &(wrq.u.frag), sizeof(iwparam));
}
/* Get operation mode */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWMODE, &wrq) >= 0)
{
if((wrq.u.mode < 6) && (wrq.u.mode >= 0))
info->has_mode = 1;
info->mode = wrq.u.mode;
}
/* Get Power Management settings */
strcpy(wrq.ifr_name, ifname);
wrq.u.power.flags = 0;
if(ioctl(skfd, SIOCGIWPOWER, &wrq) >= 0)
{
info->has_power = 1;
memcpy(&(info->power), &(wrq.u.power), sizeof(iwparam));
}
#if WIRELESS_EXT > 9
/* Get Transmit Power */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWTXPOW, &wrq) >= 0)
{
info->has_txpower = 1;
memcpy(&(info->txpower), &(wrq.u.txpower), sizeof(iwparam));
}
#endif
#if WIRELESS_EXT > 10
/* Get retry limit/lifetime */
strcpy(wrq.ifr_name, ifname);
if(ioctl(skfd, SIOCGIWRETRY, &wrq) >= 0)
{
info->has_retry = 1;
memcpy(&(info->retry), &(wrq.u.retry), sizeof(iwparam));
}
#endif /* WIRELESS_EXT > 10 */
/* Get stats */
if(iw_getstats(ifname, &(info->stats)) >= 0)
{
info->has_stats = 1;
}
return(0);
}
