Example #1
0
File: sdp.c Project: ghent360/bluez
static uint16_t common_rsp(const struct l2cap_frame *frame,
						struct tid_data *tid)
{
	uint16_t bytes;

	if (frame->size < 2) {
		print_text(COLOR_ERROR, "invalid size");
		packet_hexdump(frame->data, frame->size);
		return 0;
	}

	bytes = get_be16(frame->data);
	print_field("Attribute bytes: %d", bytes);

	if (bytes > frame->size - 2) {
		print_text(COLOR_ERROR, "invalid attribute size");
		packet_hexdump(frame->data + 2, frame->size - 2);
		return 0;
	}

	return bytes;
}
Example #2
0
/* summary_len == 0 means "no summary */
static gboolean
view_msg_plain (MuMsg *msg, MuConfig *opts)
{
	gchar *attachs;
	time_t date;
	const GSList *lst;
	gboolean color;

	color = !opts->nocolor;

	print_field ("From",    mu_msg_get_from (msg),    color);
	print_field ("To",      mu_msg_get_to (msg),      color);
	print_field ("Cc",      mu_msg_get_cc (msg),      color);
	print_field ("Bcc",     mu_msg_get_bcc (msg),     color);
	print_field ("Subject", mu_msg_get_subject (msg), color);

	if ((date = mu_msg_get_date (msg)))
		print_field ("Date", mu_date_str_s ("%c", date),
			     color);

	if ((lst = mu_msg_get_tags (msg))) {
		gchar *tags;
		tags = mu_str_from_list (lst,',');
		print_field ("Tags", tags, color);
		g_free (tags);
	}

	if ((attachs = get_attach_str (msg, opts))) {
		print_field ("Attachments", attachs, color);
		g_free (attachs);
	}

	body_or_summary (msg, opts);

	return TRUE;
}
Example #3
0
static bool bnep_control(struct bnep_frame *bnep_frame,
					uint8_t indent,	int hdr_len)
{
	uint8_t ctype;
	struct l2cap_frame *frame = &bnep_frame->l2cap_frame;
	const struct bnep_control_data *bnep_control_data = NULL;
	const char *type_str;
	int i;

	if (!l2cap_frame_get_u8(frame, &ctype))
		return false;

	for (i = 0; bnep_control_table[i].str; i++) {
		if (bnep_control_table[i].type == ctype) {
			bnep_control_data = &bnep_control_table[i];
			break;
		}
	}

	if (bnep_control_data)
		type_str = bnep_control_data->str;
	else
		type_str = "Unknown control type";

	print_field("%*c%s (0x%02x) ", indent, ' ', type_str, ctype);

	if (!bnep_control_data || !bnep_control_data->func) {
		packet_hexdump(frame->data, hdr_len - 1);
		l2cap_frame_pull(frame, frame, hdr_len - 1);
		goto done;
	}

	if (!bnep_control_data->func(bnep_frame, indent+2))
		return false;

done:
	return true;
}
Example #4
0
File: mu-cmd.c Project: jleechpe/mu
/* a summary_len of 0 mean 'don't show summary, show body */
static void
body_or_summary (MuMsg *msg, MuConfig *opts)
{
	const char *body;
	gboolean color;

	color = !opts->nocolor;
	body = mu_msg_get_body_text (msg,
				     mu_config_get_msg_options(opts));
	if (!body)
		return;

	if (opts->summary_len != 0) {
		gchar *summ;
		summ = mu_str_summarize (body, opts->summary_len);
		print_field ("Summary", summ, color);
		g_free (summ);
	} else {
		color_maybe (MU_COLOR_YELLOW);
		mu_util_print_encoded ("\n%s\n", body);
		color_maybe (MU_COLOR_DEFAULT);
	}
}
Example #5
0
static bool bnep_general(struct bnep_frame *bnep_frame,
					uint8_t indent,	int hdr_len)
{
	struct l2cap_frame *frame;
	char src_addr[20], dest_addr[20];

	if (!get_macaddr(bnep_frame, dest_addr))
		return false;

	if (!get_macaddr(bnep_frame, src_addr))
		return false;

	frame = &bnep_frame->l2cap_frame;

	if (!l2cap_frame_get_be16(frame, &proto))
		return false;

	print_field("%*cdst %s src %s [proto 0x%04x] ", indent,
					' ', dest_addr, src_addr, proto);

	return true;

}
Example #6
0
static void print_sco_routing(uint8_t routing)
{
	const char *str;

	switch (routing) {
	case 0x00:
		str = "PCM";
		break;
	case 0x01:
		str = "Transport";
		break;
	case 0x02:
		str = "Codec";
		break;
	case 0x03:
		str = "I2S";
		break;
	default:
		str = "Reserved";
		break;
	}

	print_field("SCO routing: %s (0x%2.2x)", str, routing);
}
Example #7
0
static void launch_ram_cmd(const void *data, uint8_t size)
{
	uint32_t addr = get_le32(data);

	print_field("Address: 0x%8.8x", addr);
}
Example #8
0
bool AI::run() {
  engine->click(Game::a_open, 5, 5);
  size_t size_x = engine->get_size_x();
  size_t size_y = engine->get_size_y();
  bool changed = false;
  bool won = false;
  do {
    changed = false;
    auto field = get_field();
    if(verbose){
      print_field(field, ostr);
      (*ostr) << std::endl;
    }
    for(size_t x = 0; x < size_x; x++) {
      for(size_t y = 0; y < size_y; y++) {
        if((field[x][y] >= '1') && (field[x][y] <= '8')) {
          size_t count = 0;
          engine->cycle_cells(x, y, [&field, &count](size_t x_, size_t y_) {
            if((field[x_][y_] == '#') || (field[x_][y_] == 'f')) {
              count++;
            }
          });
          if(count == (field[x][y] - '0')) {
            engine->cycle_cells(x, y, [&field, this, &changed](size_t x_, size_t y_) {
              if(field[x_][y_] == '#') {
                this->engine->click(Game::a_flag, x_, y_);
                field[x_][y_] = 'f';
                changed = true;
              }
            });
          }
        }
      }
    }
    field = get_field();
    if(verbose){
      print_field(field, ostr);
      (*ostr) << std::endl;
    }
    for(size_t x = 0; x < size_x; x++) {
      for(size_t y = 0; y < size_y; y++) {
        if((field[x][y] >= '1') && (field[x][y] <= '8')) {
          size_t count = 0;
          engine->cycle_cells(x, y, [&field, &count](size_t x_, size_t y_) {
            if(field[x_][y_] == 'f') {
              count++;
            }
          });
          if(count == (field[x][y] - '0')) {
            engine->cycle_cells(x, y, [&field, this, &changed, &won](size_t x_, size_t y_) {
              if(field[x_][y_] == '#') {
                auto code = this->engine->click(Game::a_open, x_, y_);
                if(code == 1) {
                  if(verbose){
                    print_lose();
                    (*ostr) << "I lost!" << std::endl;
                  }
                  changed = false;
                } else if (code == 2) {
                  changed = false;
                  won = true;
                  if(verbose) {
                    print();
                    (*ostr) << "I won!" << std::endl;
                  }
                }
                field = get_field();
                
              }
            });
          }
        }
      }
    }
  } while (changed);
  if(!won) {
    if(verbose) {
      (*ostr) << "Not sure what to do here..." << std::endl;
    } else {
      print();
    }
  }
  return won;
}
Example #9
0
/**
 * Lists all installed MIDlet suites. This is an example of how to use
 * the public MIDP API.
 *
 * @param argc The total number of arguments
 * @param argv An array of 'C' strings containing the arguments
 *
 * @return <tt>0</tt> for success, otherwise <tt>-1</tt>
 *
 * IMPL_NOTE: determine if it is desirable for user targeted output
 *       messages to be sent via the log/trace service, or if
 *       they should remain as printf calls
 */
int
listMidlets(int argc, char* argv[]) {
    int   status = -1;
    int   i;
    long  size;
    char* midpHome = NULL;

    (void)argv;                                   /* Avoid compiler warnings */
    if (argc > 1) {
        REPORT_ERROR(LC_AMS, "Too many arguments given");
        fprintf(stderr, "Too many arguments given\n");
        return -1;
    }

    /* get midp home directory, set it */
    midpHome = midpFixMidpHome(argv[0]);
    if (midpHome == NULL) {
        return -1;
    }
    /* set up midpHome before calling initialize */
    midpSetHomeDir(midpHome);

    if (midpInitialize() != 0) {
        REPORT_ERROR(LC_AMS, "Not enough memory");
        fprintf(stderr, "Not enough memory\n");
        return -1;
    }

    do {
        SuiteIdType* pSuites = NULL;
        int numberOfSuites = 0;
        MIDPError err;

        err = midp_get_suite_ids(&pSuites, &numberOfSuites);
        if (err != ALL_OK) {
            REPORT_ERROR1(LC_AMS, "Error in midp_get_suite_ids(), code %d",
                          err);
            fprintf(stderr, "Error in midp_get_suite_ids(), code %d.\n", err);
            break;
        }

        if (numberOfSuites == 0) {
            REPORT_ERROR(LC_AMS, "No MIDlet Suites installed on phone");
            printf("** No MIDlet Suites installed on phone\n");
            status = 0;
            break;
        }

        for (i = 0; i < numberOfSuites; i++) {
            MidpInstallInfo info;
            MidpProperties properties;

            info = midp_get_suite_install_info(pSuites[i]);
            if (BAD_ID_INFO_STATUS(info)) {
                REPORT_ERROR(LC_AMS, "Suite list is corrupt");
                fprintf(stderr, "Suite list is corrupt\n");
                break;
            }

            if (OUT_OF_MEM_INFO_STATUS(info)) {
                REPORT_ERROR(LC_AMS, "Out Of Memory for Info");
                fprintf(stderr, "Out Of Memory for Info\n");
                break;
            }

            if (SUITE_CORRUPTED_ERR_STATUS(info)) {
                /*
                 * Installinfo is not initialsed in case of an error
                 * so no need to free it
                 */
                REPORT_ERROR1(LC_AMS, "Error : Suite %d is corrupted", (i+1));
                fprintf(stderr, "Error : Suite %d is corrupted\n", (i+1));
                continue;
            }

            if (READ_ERROR_INFO_STATUS(info)) {
                REPORT_ERROR(LC_AMS, "Corrupt install info");
                fprintf(stderr, "Corrupt install info\n");
                break;
            }

            properties = midp_get_suite_properties(pSuites[i]);
            if (OUT_OF_MEM_PROPERTY_STATUS(properties)) {
                midp_free_install_info(&info);
                midp_free_properties(&properties);
                REPORT_ERROR(LC_AMS, "Out Of Memory for properties");
                fprintf(stderr, "Out Of Memory for properties\n");
                break;
            }

            if (CORRUPTED_PROPERTY_STATUS(properties)) {
                midp_free_install_info(&info);
                midp_free_properties(&properties);
                REPORT_ERROR1(LC_AMS, "Error : Suite %d is corrupted", (i+1));
                fprintf(stderr, "Error : Suite %d is corrupted\n", (i+1));
                continue;
            }

            if (READ_ERROR_PROPERTY_STATUS(properties)) {
                midp_free_install_info(&info);
                midp_free_properties(&properties);
                REPORT_ERROR(LC_AMS, "Corrupt properties");
                fprintf(stderr, "Corrupt properties\n");
                break;
            }

            printf("[%d]\n", (i + 1));
            printProperty("  Name: ", &SUITE_NAME_PROP, properties);
            printProperty("  Vendor: ", &SUITE_VENDOR_PROP, properties);
            printProperty("  Version: ", &SUITE_VERSION_PROP, properties);
            printProperty("  Description: ", &SUITE_DESC_PROP, properties);

            if (info.authPathLen > 0) {
                int j;

                puts("  Authorized by: ");
                for (j = 0; j < info.authPathLen; j++) {
                    print_field("    ", &info.authPath_as[j]);
                }
            }

            print_field("  SecurityDomain: ", &info.domain_s);
            printf("  Verified: %s\n",
                (info.pVerifyHash != NULL ? "true" : "false"));
            printf("  Suite ID: %ld\n", (long)pSuites[i]);
            print_field("  JAD URL: ", &info.jadUrl_s);
            print_field("  JAR URL: ", &info.jarUrl_s);
            size = midp_get_suite_storage_size(pSuites[i]);
            if (size < 0) {
                fprintf(stderr, "Ran out of memory getting the size\n");
            } else {
                printf("  Size: %ldK\n", (size + 1023) / 1024);
            }

            midp_free_install_info(&info);
            midp_free_properties(&properties);
        }

        midp_free_suite_ids(pSuites, numberOfSuites);

        status = 0;
    } while (0);

    midpFinalize();

    return status;
}
Example #10
0
/**
 * Prints a property value to <tt>stdout</tt>.
 *
 * @param pszLabel A 'C' string label to be printed before the
 *                 property value
 * @param key The property key of the value to print
 * @param props The properties to search for <tt>key</tt>
 */
static void
printProperty(char* pszLabel, const pcsl_string * key, MidpProperties props) {
    print_field(pszLabel, midp_find_property(&props, key));
}
Example #11
0
void uiprintfield( a_dialog *dialog, VFIELD *field )
{
    print_field( dialog->vs, field, field == dialog->curr );
}
Example #12
0
File: sdp.c Project: ghent360/bluez
static void handle_continuation(struct tid_data *tid, bool nested,
			uint16_t bytes, const uint8_t *data, uint16_t size)
{
	uint8_t *newdata;
	int i, n = -1;

	if (bytes + 1 > size) {
		print_text(COLOR_ERROR, "missing continuation state");
		return;
	}

	if (tid->cont[0] == 0x00 && data[bytes] == 0x00) {
		decode_data_elements(0, 2, data, bytes,
				nested ? print_attr_lists : print_attr_list);

		print_continuation(data + bytes, size - bytes);
		return;
	}

	for (i = 0; i < MAX_CONT; i++) {
		if (cont_list[i].cont[0] == 0x00) {
			if (n < 0)
				n = i;
			continue;
		}

		if (cont_list[i].channel != tid->channel)
			continue;

		if (cont_list[i].cont[0] != tid->cont[0])
			continue;

		if (!memcmp(cont_list[i].cont + 1,
					tid->cont + 1, tid->cont[0])) {
			n = i;
			break;
		}
	}

	print_continuation(data + bytes, size - bytes);

	if (n < 0)
		return;

	newdata = realloc(cont_list[n].data, cont_list[n].size + bytes);
	if (!newdata) {
		print_text(COLOR_ERROR, "failed buffer allocation");
		free(cont_list[n].data);
		cont_list[n].data = NULL;
		cont_list[n].size = 0;
		return;
	}

	cont_list[n].channel = tid->channel;
	cont_list[n].data = newdata;

	if (bytes > 0) {
		memcpy(cont_list[n].data + cont_list[n].size, data, bytes);
		cont_list[n].size += bytes;
	}

	if (data[bytes] == 0x00) {
		print_field("Combined attribute bytes: %d", cont_list[n].size);

		decode_data_elements(0, 2, cont_list[n].data, cont_list[n].size,
				nested ? print_attr_lists : print_attr_list);

		free(cont_list[n].data);
		cont_list[n].data = NULL;
		cont_list[n].size = 0;
	} else
		memcpy(cont_list[i].cont, data + bytes, data[bytes] + 1);
}
Example #13
0
int main (int argc, char ** argv)
{
  int i;
    
  /*
   *  this is set to either euler or runge_kutta_4
   */
  enum solver_t solver;

  /*
   *  bc (boundary condition) can be either periodic or no_slip
   */
  enum bc_t bc;

  /*
   * these specify the geometry of the area to be simulated 
   * tdim ist the total number of points, i.e. tdim = xdim *ydim 
   */
  int xdim, ydim, tdim;
  double dx, dy;

  /*
   * this holds the neighbors 
   */
  int **neighbors;

  /*
   * this holds latitude and longitude values of each point
   */
  unsigned int *lat, *lon;

  /*
   * this holds order of the data to be printed out
   */
  unsigned int *print_out_order;

  /*
   * these control temporal aspects of the simulation 
   */
  long int ncycle;
  double dt = 5.1;
  long int n_iter = 25800;
  int write_out_interval = 5000;

  /*
   * these hold the physical parameters 
   *
   * f0:              coriolis parameter (1/1sec)
   * beta:            linear beta for coriolis force (1/(meter sec))
   * forcingTerm:     Wind stress amplitude "tau_0"(N/meter^2)
   * dissipationTerm: "A" viscosity coefficient (meters^2/sec)
   * RayleighFriction: Rayleigh friction parameter (1/sec)
   */
  double f0 = 5.0e-5;
  double beta =2e-11;
  double forcingTerm = 0.0005;
  double dissipationTerm = 0.00005;
  double RayleighFriction = 5e-8;

  /*
   * upper layer equilibrium depth (meters)
   */
  double EquilibriumDepth = 50000.0;
  double A;

  /*
   * this holds the physical parameters and the forcing
   */
  double *parameters;
  double *x_forcing, *y_forcing, *z_forcing;

  /*
   * "fields" holds the values of the u, v and P fields
   */
  double *fields;
  double *u, *v, *P;     

  /*
   * "fields_prev" holds the u, v and P values of the previous time step
   */
  //double *fields_prev;
  //double *u_prev, *v_prev, *P_prev;     

  /*
   * these are temporary storage locations 
   * for the Runge-Kutta scheme
   */
  double *temp_dots_rk;
  double *temp_fields_rk;

  /*
   * read parameters from command line
   */
  if(argc == 2){

    get_parameters(argv[1], &xdim, &ydim, &dx, &dy, &n_iter, &dt, &write_out_interval, &bc, &solver, &f0, &beta, &forcingTerm, &dissipationTerm, &RayleighFriction, &EquilibriumDepth, &A);

  }
  else{

    fprintf(stderr, "ERROR: You need to give a file containing the parameters as an argument!\n");
    exit(1);

  }

  print_parameters(xdim, ydim, dx, dy, n_iter, dt, write_out_interval, bc, solver, f0, beta, forcingTerm, dissipationTerm, RayleighFriction, EquilibriumDepth, A);

  tdim = xdim*ydim;

  /*
   *  allocate arrays containing geometrical information and fill these
   */
  lat = calloc(tdim, sizeof(unsigned int)); 
  lon = calloc(tdim, sizeof(unsigned int)); 
  print_out_order = calloc(tdim, sizeof(unsigned int)); 
  neighbors = calloc(tdim, sizeof(int*)); 
  for(i=0; i< tdim; i++){
    neighbors[i] = calloc(4, sizeof(int));
  }

  initialize_geometry(xdim, ydim, neighbors, lat, lon, print_out_order);

  /*
   * allocate memory for physical parameters and forcing
   */
  parameters = calloc(5+3*tdim, sizeof(double));

  parameters[0] = f0;
  parameters[1] = beta;
  parameters[2] = forcingTerm;
  parameters[3] = dissipationTerm;
  parameters[4] = RayleighFriction;

  x_forcing = parameters + 5;
  y_forcing = parameters + 5 + tdim;
  z_forcing = parameters + 5 + 2*tdim;

  /*
   * allocate "fields" and set addresses for u, v, and P
   */
  fields = calloc(3*tdim, sizeof(double));
  u = fields;
  v = fields + tdim;
  P = fields + 2 * tdim;

  /*
   * allocate "fields_prev" and set addresses for u_prev, v_prev, and P_prev
   */
  //fields_prev = calloc(3*tdim, sizeof(double));
  //u_prev = fields_prev;
  //v_prev = fields_prev + tdim;
  //P_prev = fields_prev + 2 * tdim;

  double *fields_dot;
  fields_dot = calloc(3*tdim, sizeof(double));

  /*
   * allocate memory for temporary Runge-Kutta storage locations 
   */
  temp_dots_rk = calloc(3*tdim, sizeof(double));
  temp_fields_rk = calloc(3*tdim, sizeof(double));

  /*
   * initialize fields
   */
  initialize_fields (u, v, P, x_forcing, y_forcing, z_forcing, xdim, ydim, dx, dy, EquilibriumDepth, A, neighbors, lat, lon, bc);

  /*
   *  loop through time steps to do the actual simulation
   */
  for (ncycle=0; ncycle<n_iter; ncycle++) {
    //printf("step #%li\n", ncycle);

    /*
     * print result
     */
    if(ncycle % write_out_interval == 0){
      print_field(u, "u", ncycle, xdim, ydim, print_out_order);
      print_field(v, "v", ncycle, xdim, ydim, print_out_order);
      print_field(P, "P", ncycle, xdim, ydim, print_out_order);
      printf("%li ", ncycle);
      fflush(stdout);
    }
    Fcalc(fields_dot, fields, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
 

    //for (i=0;i<3*tdim;i++) {
    //  fields_prev[i] = fields[i];
    //}

    if(solver == runge_kutta_4){

      /*
       *  Runge-Kutta 4th order
       *
       *                 dt
       *    y_1 = y_0 + ---- (y'_0 + 2 * y'_A + 2 * y'_B +y'_C)
       *                  6
       */

      /*                          dt
       * first step: y_A = y_0 + ---- y'_0
       *                          2
       */
      for (i=0; i < 3*tdim;  i++) {
        temp_fields_rk[i] = fields[i]+0.5*dt*fields_dot[i];
      }
      Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
      for (i=0; i < 3*tdim;  i++) {
        fields_dot[i] += 2*temp_dots_rk[i];
      }

      /*                           dt
       * second step: y_B = y_0 + ---- y'_A
       *                            2
       */
      for (i=0; i < 3*tdim;  i++) {
        temp_fields_rk[i] = fields[i]+0.5*dt*temp_dots_rk[i];
      }
      Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
      for (i=0; i < 3*tdim;  i++) {
        fields_dot[i] += 2*temp_dots_rk[i];
      }

      /*
       * third step: y_C = y_0 + dt * y'_B
       */
      for (i=0; i < 3*tdim;  i++){
        temp_fields_rk[i] = fields[i]+dt*temp_dots_rk[i];
      }
      Fcalc(temp_dots_rk, temp_fields_rk, parameters, xdim, ydim, dx, dy, neighbors, lat, bc, print_out_order, ncycle);
      for (i=0; i < 3*tdim;  i++) {
        fields_dot[i] += temp_dots_rk[i];
      }

      /*                          dt
       * final step: y_1 = y_0 + ---- (y'_0 + 2 * y'_A + 2 * y'_B +y'_C)
       *                           6
       */
      for (i=0; i < 3*tdim;  i++) {
        fields_dot[i] /= 6.0;
        fields[i] += dt*fields_dot[i];
      }
    }
    else{

      if(solver == euler){

        /*
         *  the Euler scheme
         */
        for (i=0; i < 3*tdim;  i++) {
          fields[i] += dt*fields_dot[i];
        }
      }
      else{
        fprintf(stderr, "ERROR: No valid solver was found\n");
        exit(2);
      }
    }
  }
  printf("\n");

  return(0);
}
void InstructionPrinter::do_LoadField(LoadField* x) {
  print_field(x);
}
Example #15
0
static inline bool mcc_frame(struct rfcomm_frame *rfcomm_frame, uint8_t indent)
{
	uint8_t length, ex_length, type;
	const char *type_str;
	int i;
	struct l2cap_frame *frame = &rfcomm_frame->l2cap_frame;
	struct rfcomm_lmcc mcc;
	const struct mcc_data *mcc_data = NULL;

	if (!l2cap_frame_get_u8(frame, &mcc.type) ||
			!l2cap_frame_get_u8(frame, &length))
		return false;

	if (RFCOMM_TEST_EA(length))
		mcc.length = (uint16_t) GET_LEN8(length);
	else {
		if (!l2cap_frame_get_u8(frame, &ex_length))
			return false;
		mcc.length = ((uint16_t) length << 8) | ex_length;
		mcc.length = GET_LEN16(mcc.length);
	}

	type = RFCOMM_GET_MCC_TYPE(mcc.type);

	for (i = 0; mcc_table[i].str; i++) {
		if (mcc_table[i].type == type) {
			mcc_data = &mcc_table[i];
			break;
		}
	}

	if (mcc_data)
		type_str = mcc_data->str;
	else
		type_str = "Unknown";

	print_field("%*cMCC Message type: %s %s (0x%2.2x)", indent, ' ',
				type_str, CR_STR(mcc.type), type);

	print_field("%*cLength: %d", indent+2, ' ', mcc.length);

	rfcomm_frame->mcc = mcc;

	switch (type) {
	case RFCOMM_TEST:
		return mcc_test(rfcomm_frame, indent+10);
	case RFCOMM_MSC:
		return mcc_msc(rfcomm_frame, indent+2);
	case RFCOMM_RPN:
		return mcc_rpn(rfcomm_frame, indent+2);
	case RFCOMM_RLS:
		return mcc_rls(rfcomm_frame, indent+2);
	case RFCOMM_PN:
		return mcc_pn(rfcomm_frame, indent+2);
	case RFCOMM_NSC:
		return mcc_nsc(rfcomm_frame, indent+2);
	default:
		packet_hexdump(frame->data, frame->size);
	}

	return true;
}
Example #16
0
/**
 * Reentrant formatted print.
 *
 * Supported '%' format characters:
 * - 's'  const char *  null terminated string as text or "(null)"
 * - 'x'  int/long      hexadecimal '0xnn'
 * - 'X'  int/long      hexadecimal '0XNN'
 * - 'u'  int/long      unsigned decimal
 * - 'd'  int/long      signed decimal
 * - 'i'  int/long      signed decimal
 * - 'p'  pointer       pointer value is printed as "0xnnnn" (IF CONFIGURED)
 * - 'c'  char          single character
 * - 'o'  int/long      octal numbers (IF CONFIGURED)
 *
 * Supported flags:
 * - '#'  use alternate form (IF CONFIGURED)
 * - 'l'  use long instead of int for numbers (IF CONFIGURED)
 * - 'll' use long long for numbers (IF CONFIGURED)
 * - '-'  align left
 * - ' '  prefix non-negative numbers with single space
 * - '+'  prefix non-negative numbers with plus
 * - '0'  pad with '0' instead of ' '
 * - '*'  fetch width from the argument list (unsigned int)
 *
 * The field width (e.g. "%10s") can also be specified.
 * The field precision (e.g. "%10.3s" can also be specified (IF CONFIGURED)
 *
 * Unsupported are:
 * - float numbers (format char: e E f F g G a A)
 * - write-back character count ("%n")
 *
 * @param write_char    [in] function used to write characters
 * @param format        [in] format string
 * @param args          [in] variable argument list
 * @return the number of characters that were written
 */
int
embtextf_vuprintf (embtextf_putchar_fn write_char, const char *format, va_list args)
{
  int character_count = 0;
  enum
  { DIRECT, FORMATING } mode = DIRECT;
  unsigned int wp_value = 0;
  unsigned int width = 0;
  flags_t flags;
  const char* specifier = format;
  char *char_p;
  char character;
  int radix;
  char have_wp_value = 0;
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
  char have_precision = 0;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
  char is_zero = 0;
  char is_negative = 0;
  union {
    int i;
#if EMBTEXTF_ENABLE_VUPRINTF_INTPTR - 0
    intptr_t ptr;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_INTPTR */
#if EMBTEXTF_ENABLE_VUPRINTF_LONG - 0
    long int li;
#if EMBTEXTF_ENABLE_VUPRINTF_LONGLONG - 0
    long long int lli;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONGLONG */
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONG */
  } number;
  char buffer[MAX_FORMAT_LENGTH];       /*  used to print numbers */

  while ((character = *format++)) {
    /*  test and save character */
    if (mode == DIRECT) {
      /*  output characters from the format string directly, except the */
      /*  '%' sign which changes the mode */
      if (character == '%') {
        width = wp_value = 0;
        memset(&flags, 0, sizeof(flags));
        have_wp_value = is_zero = is_negative = 0;
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
        have_precision = 0;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
        specifier = format - 1;
        mode = FORMATING;
      } else {
write_character:
        write_char(character);
        character_count++;
        mode = DIRECT;
      }
    } else {
      /* FORMATING */
      /*  process format characters */
      switch (character) {
          /*  output '%' itself */
        case '%':
          goto write_character; /*  character is already the % */

#if EMBTEXTF_ENABLE_VUPRINTF_ALTERNATE_FORM - 0
          /*  alternate form flag */
        case '#':
          flags.is_alternate_form = 1;
          break;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_ALTERNATE_FORM */

#if EMBTEXTF_ENABLE_VUPRINTF_LONG - 0
          /*  interpret next number as long integer */
        case 'l':
#if EMBTEXTF_ENABLE_VUPRINTF_LONGLONG - 0
          if (flags.is_longlong) {
            goto bad_format;
          } else if (flags.is_long) {
            flags.is_long = 0;
            flags.is_longlong = 1;
          } else
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONGLONG */
          {
            if (flags.is_long) {
              goto bad_format;
            }
            flags.is_long = 1;
          }
          break;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONG */

          /*  left align instead of right align */
        case '-':
          flags.left_align = 1;
          break;

          /*  emit a + before a positive number */
        case '+':
          flags.sign_char = '+';
          break;

          /*  emit a space before a positive number */
        case ' ':
          /*  + overrides space as a flag character */
          if ('+' != flags.sign_char) {
            flags.sign_char = ' ';
          }
          break;

#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
        case '.':
          /*  explicit precision is present */
          if (have_wp_value) {
            width = wp_value;
            wp_value = 0;
            have_wp_value = 0;
          }
          have_precision = 1;
          break;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
          /*  fetch length from argument list instead of the format */
          /*  string itself */
        case '*': {
          int val = va_arg(args, int);

          if (val >= 0) {
            wp_value = val;
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
          } else if (have_precision) {
            wp_value = 0;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
          } else {
            flags.left_align = 1;
            wp_value = -val;
          }
          have_wp_value = 1;
          break;
        }

        /*  format field width. zero needs special treatment */
        /*  as when it occurs as first number it is the */
        /*  flag to pad with zeroes instead of spaces */
        case '0':
          /*  a leading zero means filling with zeros */
          /*  it must be a leading zero if 'width' is zero */
          /*  otherwise it is in a number as in "10" */
          if (wp_value == 0
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
              && !have_precision
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
             ) {
            flags.fill_zero = !flags.left_align;
            break;
          }
          /*@[email protected] */
        case '1':
        case '2':
        case '3':
        case '4':
        case '5':
        case '6':
        case '7':
        case '8':
        case '9':
          wp_value *= 10;
          wp_value += character - '0';
          have_wp_value = 1;
          break;

          /*  placeholder for one character */
        case 'c':
          character = va_arg(args, int);
          if (! have_wp_value
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
              && ! have_precision
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
             ) {
            goto write_character;
          }
          char_p = buffer;
          buffer[0] = character;
          buffer[1] = 0;
          goto emit_string;

          /*  placeholder for arbitrary length null terminated */
          /*  string */
        case 's':
          char_p = va_arg(args, char *);
emit_string:
          /* Note: Zero-padding on strings is undefined; it
           * is legitimate to zero-pad */
#if EMBTEXTF_ENABLE_VUPRINTF_PRECISION - 0
          if (have_precision) {
            flags.truncate_precision = 1;
            flags.precision = wp_value;
          } else
#endif /* EMBTEXTF_ENABLE_VUPRINTF_PRECISION */
            if (have_wp_value) {
              width = wp_value;
            }
          character_count += print_field(write_char,
                                         (char_p != NULL) ? char_p : "(null)",
                                         width, flags);
          mode = DIRECT;
          break;

#if EMBTEXTF_ENABLE_VUPRINTF_INTPTR - 0
          /*  placeholder for an address */
          /*  addresses are automatically in alternate form and */
          /*  hexadecimal. */
        case 'p':
          number.ptr = (intptr_t) va_arg(args, void *);
          number.ptr &= UINTPTR_MAX;
          radix = 16;
#if EMBTEXTF_ENABLE_VUPRINTF_ALTERNATE_FORM - 0
          flags.is_alternate_form = (0 != number.ptr);
#endif /* EMBTEXTF_ENABLE_VUPRINTF_ALTERNATE_FORM */
          goto emit_number;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_INTPTR */

          /* hexadecimal output */
        case 'X':
          flags.uppercase = 1;
          /*@[email protected] */
        case 'x':
          radix = 16;
          goto fetch_number;

#if EMBTEXTF_ENABLE_VUPRINTF_OCTAL - 0
          /* octal output */
        case 'o':
          radix = 8;
          goto fetch_number;
#endif /* EMBTEXTF_ENABLE_VUPRINTF_OCTAL */

          /* decimal signed numbers */
        case 'd':
        case 'i':
          flags.is_signed = 1;
          /*@[email protected] */
          /*  decimal unsigned numbers */
        case 'u':
          radix = 10;
          /*  label for number outputs including argument fetching */
fetch_number:
#if EMBTEXTF_ENABLE_VUPRINTF_LONG - 0
#if EMBTEXTF_ENABLE_VUPRINTF_LONGLONG - 0
          if (flags.is_longlong) {
            number.lli = va_arg(args, long long int);
            is_zero = (number.lli == 0);
            is_negative = (number.lli < 0);
          } else
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONGLONG */
            if (flags.is_long) {
              number.li = va_arg(args, long int);
              is_zero = (number.li == 0);
              is_negative = (number.li < 0);
            } else
#endif /* EMBTEXTF_ENABLE_VUPRINTF_LONG */
            {
void InstructionPrinter::do_StoreField(StoreField* x) {
  print_field(x);
  output()->print(" := ");
  print_value(x->value());
  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
}
void InstructionPrinter::do_LoadField(LoadField* x) {
  print_field(x);
  output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
}
Example #19
0
File: sdp.c Project: ghent360/bluez
static void print_boolean(uint8_t indent, const uint8_t *data, uint32_t size)
{
	print_field("%*c%s", indent, ' ', data[0] ? "true" : "false");
}
Example #20
0
void uiprintfield( a_dialog *ui_dlg_info, VFIELD *field )
{
    print_field( ui_dlg_info->vs, field, field == ui_dlg_info->curr );
}
Example #21
0
void broadcom_lm_diag(const void *data, uint8_t size)
{
	uint8_t type;
	uint32_t clock;
	const uint8_t *addr;
	const char *str;

	if (size != 63) {
		packet_hexdump(data, size);
		return;
	}

	type = *((uint8_t *) data);
	clock = get_be32(data + 1);

	switch (type) {
	case 0x00:
		str = "LMP sent";
		break;
	case 0x01:
		str = "LMP receive";
		break;
	case 0x80:
		str = "LL sent";
		break;
	case 0x81:
		str = "LL receive";
		break;
	default:
		str = "Unknown";
		break;
	}

	print_field("Type: %s (%u)", str, type);
	print_field("Clock: 0x%8.8x", clock);

	switch (type) {
	case 0x00:
		addr = data + 5;
		print_field("Address: --:--:%2.2X:%2.2X:%2.2X:%2.2X",
					addr[0], addr[1], addr[2], addr[3]);
		packet_hexdump(data + 9, 1);
		lmp_packet(data + 10, size - 10, true);
		break;
	case 0x01:
		addr = data + 5;
		print_field("Address: --:--:%2.2X:%2.2X:%2.2X:%2.2X",
					addr[0], addr[1], addr[2], addr[3]);
		packet_hexdump(data + 9, 4);
		lmp_packet(data + 13, size - 13, true);
		break;
	case 0x80:
	case 0x81:
		packet_hexdump(data + 5, 7);
		llcp_packet(data + 12, size - 12, true);
		break;
	default:
		packet_hexdump(data + 9, size - 9);
		break;
	}
}
Example #22
0
File: sdp.c Project: ghent360/bluez
static void decode_data_elements(uint32_t position, uint8_t indent,
				const uint8_t *data, uint32_t size,
				void (*print_func) (uint32_t, uint8_t, uint8_t,
						const uint8_t *, uint32_t))

{
	uint32_t datalen, elemlen, extrabits;
	int i;

	if (!size)
		return;

	extrabits = get_bits(data, size);

	if (size < 1 + (extrabits / 8)) {
		print_text(COLOR_ERROR, "data element descriptor too short");
		packet_hexdump(data, size);
		return;
	}

	datalen = get_size(data, size);

	if (size < 1 + (extrabits / 8) + datalen) {
		print_text(COLOR_ERROR, "data element size too short");
		packet_hexdump(data, size);
		return;
	}

	elemlen = 1 + (extrabits / 8) + datalen;

	for (i = 0; type_table[i].str; i++) {
		uint8_t type = (data[0] & 0xf8) >> 3;

		if (type_table[i].value != type)
			continue;

		if (print_func) {
			print_func(position, indent, type,
					data + 1 + (extrabits / 8), datalen);
			break;
		}

		print_field("%*c%s (%d) with %u byte%s [%u extra bits] len %u",
					indent, ' ', type_table[i].str, type,
					datalen, datalen == 1 ? "" : "s",
					extrabits, elemlen);
		if (!valid_size(data[0] & 0x07, type_table[i].sizes)) {
			print_text(COLOR_ERROR, "invalid data element size");
			packet_hexdump(data + 1 + (extrabits / 8), datalen);
			break;
		}

		if (type_table[i].recurse)
			decode_data_elements(0, indent + 2,
					data + 1 + (extrabits / 8), datalen,
								print_func);
		else if (type_table[i].print)
			type_table[i].print(indent + 2,
					data + 1 + (extrabits / 8), datalen);
		break;
	}

	if (elemlen > size) {
		print_text(COLOR_ERROR, "invalid data element size");
		return;
	}

	data += elemlen;
	size -= elemlen;

	decode_data_elements(position + 1, indent, data, size, print_func);
}
void InstructionPrinter::do_StoreField(StoreField* x) {
  print_field(x);
  tty->print(" := ");
  print_value(x->value());
}
Example #24
0
static void print_full_information(void)
{
    static const WCHAR newlineW[] = {'\n',0};
    static const WCHAR emptyW[] = {0};

    FIXED_INFO *info;
    IP_ADAPTER_ADDRESSES *adapters;
    ULONG out = 0;

    if (GetNetworkParams(NULL, &out) == ERROR_BUFFER_OVERFLOW)
    {
        info = HeapAlloc(GetProcessHeap(), 0, out);
        if (!info)
            exit(1);

        if (GetNetworkParams(info, &out) == ERROR_SUCCESS)
        {
            WCHAR hostnameW[MAX_HOSTNAME_LEN + 4];

            MultiByteToWideChar(CP_ACP, 0, info->HostName, -1, hostnameW, sizeof(hostnameW)/sizeof(hostnameW[0]));
            print_field(STRING_HOSTNAME, hostnameW);

            /* FIXME: Output primary DNS suffix. */

            print_field(STRING_NODE_TYPE, nodetype_to_string(info->NodeType));
            print_field(STRING_IP_ROUTING, boolean_to_string(info->EnableRouting));

            /* FIXME: Output WINS proxy status and DNS suffix search list. */

            ipconfig_printfW(newlineW);
        }

        HeapFree(GetProcessHeap(), 0, info);
    }

    if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
                             NULL, NULL, &out) == ERROR_BUFFER_OVERFLOW)
    {
        adapters = HeapAlloc(GetProcessHeap(), 0, out);
        if (!adapters)
            exit(1);

        if (GetAdaptersAddresses(AF_UNSPEC, GAA_FLAG_INCLUDE_ALL_GATEWAYS,
                                 NULL, adapters, &out) == ERROR_SUCCESS)
        {
            IP_ADAPTER_ADDRESSES *p;

            for (p = adapters; p; p = p->Next)
            {
                IP_ADAPTER_UNICAST_ADDRESS *addr;
                WCHAR physaddr_buf[3 * MAX_ADAPTER_ADDRESS_LENGTH];
                IP_ADAPTER_GATEWAY_ADDRESS_LH *gateway;
                WCHAR addr_buf[54];

                ipconfig_message_printfW(STRING_ADAPTER_FRIENDLY, iftype_to_string(p->IfType), p->FriendlyName);
                ipconfig_printfW(newlineW);
                print_field(STRING_CONN_DNS_SUFFIX, p->DnsSuffix);
                print_field(STRING_DESCRIPTION, p->Description);
                print_field(STRING_PHYS_ADDR, physaddr_to_string(physaddr_buf, p->PhysicalAddress, p->PhysicalAddressLength));
                print_field(STRING_DHCP_ENABLED, boolean_to_string(p->Flags & IP_ADAPTER_DHCP_ENABLED));

                /* FIXME: Output autoconfiguration status. */

                for (addr = p->FirstUnicastAddress; addr; addr = addr->Next)
                {
                    if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &addr->Address))
                        print_field(STRING_IP_ADDRESS, addr_buf);
                    /* FIXME: Output corresponding subnet mask. */
                }

                if (p->FirstGatewayAddress)
                {
                    if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &p->FirstGatewayAddress->Address))
                        print_field(STRING_DEFAULT_GATEWAY, addr_buf);

                    for (gateway = p->FirstGatewayAddress->Next; gateway; gateway = gateway->Next)
                    {
                        if (socket_address_to_string(addr_buf, sizeof(addr_buf)/sizeof(WCHAR), &gateway->Address))
                            print_value(addr_buf);
                    }
                }
                else
                    print_field(STRING_DEFAULT_GATEWAY, emptyW);

                ipconfig_printfW(newlineW);
            }
        }

        HeapFree(GetProcessHeap(), 0, adapters);
    }
}
Example #25
0
static void advertising_packet(const void *data, uint8_t size)
{
	const uint8_t *ptr = data;
	uint8_t pdu_type, length, win_size, hop, sca;
	bool tx_add, rx_add;
	uint32_t access_addr, crc_init;
	uint16_t win_offset, interval, latency, timeout;
	const char *str;

	if (size < 2) {
		print_text(COLOR_ERROR, "packet too short");
		packet_hexdump(data, size);
		return;
	}

	pdu_type = ptr[0] & 0x0f;
	tx_add = !!(ptr[0] & 0x40);
	rx_add = !!(ptr[0] & 0x80);
	length = ptr[1] & 0x3f;

	switch (pdu_type) {
	case 0x00:
		str = "ADV_IND";
		break;
	case 0x01:
		str = "ADV_DIRECT_IND";
		break;
	case 0x02:
		str = "ADV_NONCONN_IND";
		break;
	case 0x03:
		str = "SCAN_REQ";
		break;
	case 0x04:
		str = "SCAN_RSP";
		break;
	case 0x05:
		str = "CONNECT_REQ";
		break;
	case 0x06:
		str = "ADV_SCAN_IND";
		break;
	default:
		str = "Reserved";
		break;
	}

	print_field("Type: %s (0x%2.2x)", str, pdu_type);
	print_field("TxAdd: %u", tx_add);
	print_field("RxAdd: %u", rx_add);
	print_field("Length: %u", length);

	if (length != size - 2) {
		print_text(COLOR_ERROR, "packet size mismatch");
		packet_hexdump(data + 2, size - 2);
		return;
	}

	switch (pdu_type) {
	case 0x00:	/* ADV_IND */
	case 0x02:	/* AVD_NONCONN_IND */
	case 0x06:	/* ADV_SCAN_IND */
	case 0x04:	/* SCAN_RSP */
		if (length < 6) {
			print_text(COLOR_ERROR, "payload too short");
			packet_hexdump(data + 2, length);
			return;
		}

		packet_print_addr("Advertiser address", data + 2, tx_add);
		packet_print_ad(data + 8, length - 6);
		break;

	case 0x01:	/* ADV_DIRECT_IND */
		if (length < 12) {
			print_text(COLOR_ERROR, "payload too short");
			packet_hexdump(data + 2, length);
			return;
		}

		packet_print_addr("Advertiser address", data + 2, tx_add);
		packet_print_addr("Inititator address", data + 8, rx_add);
		break;

	case 0x03:	/* SCAN_REQ */
		if (length < 12) {
			print_text(COLOR_ERROR, "payload too short");
			packet_hexdump(data + 2, length);
			return;
		}

		packet_print_addr("Scanner address", data + 2, tx_add);
		packet_print_addr("Advertiser address", data + 8, rx_add);
		break;

	case 0x05:	/* CONNECT_REQ */
		if (length < 34) {
			print_text(COLOR_ERROR, "payload too short");
			packet_hexdump(data + 2, length);
			return;
		}

		packet_print_addr("Inititator address", data + 2, tx_add);
		packet_print_addr("Advertiser address", data + 8, rx_add);

		access_addr = ptr[14] | ptr[15] << 8 |
					ptr[16] << 16 | ptr[17] << 24;
		crc_init = ptr[18] | ptr[19] << 8 | ptr[20] << 16;

		print_field("Access address: 0x%8.8x", access_addr);
		print_field("CRC init: 0x%6.6x", crc_init);

		set_crc_init(access_addr, crc24_bit_reverse(crc_init));

		win_size = ptr[21];
		win_offset = ptr[22] | ptr[23] << 8;
		interval = ptr[24] | ptr[25] << 8;
		latency = ptr[26] | ptr[27] << 8;
		timeout = ptr[28] | ptr[29] << 8;

		print_field("Transmit window size: %u", win_size);
		print_field("Transmit window offset: %u", win_offset);
		print_field("Connection interval: %u", interval);
		print_field("Connection slave latency: %u", latency);
		print_field("Connection supervision timeout: %u", timeout);

		packet_print_channel_map_ll(ptr + 30);

		hop = ptr[35] & 0x1f;
		sca = (ptr[35] & 0xe0) >> 5;

		switch (sca) {
		case 0:
			str = "251 ppm to 500 ppm";
			break;
		case 1:
			str = "151 ppm to 250 ppm";
			break;
		case 2:
			str = "101 ppm to 150ppm";
			break;
		case 3:
			str = "76 ppm to 100 ppm";
			break;
		case 4:
			str = "51 ppm to 75 ppm";
			break;
		case 5:
			str = "31 ppm to 50 ppm";
			break;
		case 6:
			str = "21 ppm to 30 ppm";
			break;
		case 7:
			str = "0 ppm to 20 ppm";
			break;
		default:
			str = "Invalid";
			break;
		}

		print_field("Hop increment: %u", hop);
		print_field("Sleep clock accuracy: %s (%u)", str, sca);
		break;

	default:
		packet_hexdump(data + 2, length);
		break;
	}
}
Example #26
0
ui_event uiprocessdialogevent( ui_event ui_ev, a_dialog *ui_dlg_info )
{
    VFIELD              *field;
    a_check             *check;
    an_edit_control     *edit;
    unsigned            choice;
    a_combo_box         *combo;
    a_list              *list;

    ui_ev = uicheckmove( ui_ev, ui_dlg_info );
    ui_ev = uitabkey( ui_ev, ui_dlg_info );
    field = ui_dlg_info->curr;
    if( field != NULL ) {
        switch( field->typ ) {
        case FLD_CHECK:
        case FLD_RADIO:
            switch( ui_ev ) {
            case EV_MOUSE_DCLICK:
            case EV_MOUSE_PRESS:
            case ' ' :
                ui_ev = EV_CHECK_BOX_CLICK;
                if( field->typ == FLD_RADIO ) {
                    do_radio( ui_dlg_info, field );
                    break;
                }
                if( field->typ == FLD_CHECK ) {
                    ui_dlg_info->dirty = true;
                    check = field->u.check;
                    check->val = !check->val;
                    print_field( ui_dlg_info->vs, field, true );
                    break;
                }
            }
            break;
        case FLD_EDIT:
        case FLD_INVISIBLE_EDIT:
            ui_ev = uiledit( ui_ev );
            edit = field->u.edit;
            if( ui_dlg_info->edit_data != NULL ) {
                edit->buffer = ui_dlg_info->edit_data->edit_buffer;
                edit->length = ui_dlg_info->edit_data->edit_eline.length;
            }
            break;
        case FLD_LISTBOX:
        case FLD_EDIT_MLE:
            list = field->u.list;
            ui_ev = uilistbox( ui_ev, list, true );
            break;
        case FLD_PULLDOWN:
            list = field->u.list;
            if( list->box == NULL ) {
                ui_ev = pulldownfilter( ui_ev, ui_dlg_info );
            } else {
                choice = list->choice;
                ui_ev = uilistbox( ui_ev, list, false );
                if( choice != list->choice ) {
                    ui_dlg_info->dirty = true;
                    print_field( ui_dlg_info->vs, field, true );
                }
            }
            break;
        case FLD_COMBOBOX:
            combo = field->u.combo;
            list  = &combo->list;
            edit  = &combo->edit;
            if( list->box == NULL ) {
                ui_ev = pulldownfilter( ui_ev, ui_dlg_info );
            } else {
                choice = list->choice;
                ui_ev = uilistbox( ui_ev, list, combo->perm );
                if( choice != list->choice ) {
                    ui_dlg_info->dirty = true;
                    setcombobuffer( ui_dlg_info, field );
                    print_field( ui_dlg_info->vs, field, true );
                }
            }
            ui_ev = uiledit( ui_ev );
            if( ui_dlg_info->edit_data != NULL ) {
                edit->buffer = ui_dlg_info->edit_data->edit_buffer;
                edit->length = ui_dlg_info->edit_data->edit_eline.length;
            }
            break;
        }
    }
    ui_ev = uihotkeyfilter( ui_dlg_info, ui_ev );
    ui_ev = uihotspotfilter( ui_dlg_info->vs, ui_dlg_info->fields, ui_ev );
    return( ui_ev );
}
Example #27
0
EVENT uiprocessdialogevent( EVENT ev, a_dialog *info )
{
    VFIELD              *field;
    a_check             *check;
    an_edit_control     *edit;
    unsigned            choice;
    a_combo_box         *combo;
    a_list              *list;

    ev = uicheckmove( ev, info );
    ev = uitabkey( ev, info );
    field = info->curr;
    if( field != NULL ) {
        switch( field->typ ) {
        case FLD_CHECK:
        case FLD_RADIO:
            switch( ev ) {
            case EV_MOUSE_DCLICK:
            case EV_MOUSE_PRESS:
            case ' ' :
                ev = EV_CHECK_BOX_CLICK;
                if( field->typ == FLD_RADIO ) {
                    do_radio( info, field );
                    break;
                }
                if( field->typ == FLD_CHECK ) {
                    info->dirty = TRUE;
                    check = field->ptr;
                    check->val = !check->val;
                    print_field( info->vs, field, TRUE );
                    break;
                }
            }
            break;
        case FLD_EDIT:
        case FLD_INVISIBLE_EDIT:
            ev = uiledit( ev );
            edit = field->ptr;
            if( info->edit_data != NULL ) {
                edit->buffer = info->edit_data->edit_buffer;
                edit->length = info->edit_data->edit_eline.length;
            }
            break;
        case FLD_LISTBOX:
        case FLD_EDIT_MLE:
            list = field->ptr;
            ev = uilistbox( ev, list, TRUE );
            break;
        case FLD_PULLDOWN:
            list = field->ptr;
            if( list->box == NULL ) {
                ev = pulldownfilter( ev, info );
            } else {
                choice = list->choice;
                ev = uilistbox( ev, list, FALSE );
                if( choice != list->choice ) {
                    info->dirty = TRUE;
                    print_field( info->vs, field, TRUE );
                }
            }
            break;
        case FLD_COMBOBOX:
            combo = field->ptr;
            list  = &combo->list;
            edit  = &combo->edit;
            if( list->box == NULL ) {
                ev = pulldownfilter( ev, info );
            } else {
                choice = list->choice;
                ev = uilistbox( ev, list, combo->perm );
                if( choice != list->choice ) {
                    info->dirty = TRUE;
                    setcombobuffer( info, field );
                    print_field( info->vs, field, TRUE );
                }
            }
            ev = uiledit( ev );
            if( info->edit_data != NULL ) {
                edit->buffer = info->edit_data->edit_buffer;
                edit->length = info->edit_data->edit_eline.length;
            }
            break;
        }
    }
    ev = uihotkeyfilter( info, ev );
    ev = uihotspotfilter( info->vs, info->fields, ev );
    return( ev );
}
Example #28
0
static ui_event pulldownfilter( ui_event ui_ev, a_dialog *ui_dlg_info )
{
    a_list          *list = NULL;
    a_combo_box     *combo;

    VSCREEN     *vs;
    SAREA       area;
    VFIELD      *fld;

    fld = ui_dlg_info->curr;

    if( fld->typ == FLD_PULLDOWN ) {
        list = fld->u.list;
    } else if( fld->typ == FLD_COMBOBOX ) {
        combo = fld->u.combo;
        list = &combo->list;
    }
    switch( ui_ev ) {
    case EV_MOUSE_DCLICK:
    case EV_MOUSE_PRESS:
    {
        ORD             row, col;

        uivmousepos( ui_dlg_info->vs, &row, &col );
        area = fld->area;
        area.width += 1;    /* extra column for button */
        if( fld->typ == FLD_COMBOBOX ) {
            /* mouse press must be on little button at right */
            area.col += area.width;
            area.width = 1;
        }
        if( fld->typ == FLD_COMBOBOX || fld->typ == FLD_PULLDOWN ) {
            /* mouse press must be on top line */
            area.height = 1;
        }
        if( row < area.row || row >= area.row + area.height )
            break;
        if( col < area.col || col >= area.col + area.width ) {
            break;
        }
        /* FALLS into next case */
    }
    case EV_CURSOR_DOWN:
    case EV_ALT_CURSOR_DOWN:
        /* list->box must be null */
        area = fld->area;
        vs   = ui_dlg_info->vs;
        area.row += ( vs->area.row + 2 );
        area.col += vs->area.col;
        if( fld->typ == FLD_COMBOBOX ) {
            area.col++;
        }
        if( area.row + area.height >= UIData->height ) {
            area.row -= area.height + 3;
        }
        vs = uiopen( &area, NULL, V_DIALOGUE | V_LISTBOX );
        area.row = 0;
        area.col = 0;
        list->box = uibeglistbox( vs, &area, list );
        if( ui_ev != EV_MOUSE_PRESS && ui_ev != EV_MOUSE_DCLICK
                        && fld->typ == FLD_COMBOBOX ) {
            ui_dlg_info->dirty = true;
            setcombobuffer( ui_dlg_info, fld );
            print_field( ui_dlg_info->vs, fld, true );
        }
        break;
    }
    return( ui_ev );
}
Example #29
0
EVENT   pulldownfilter( EVENT ev, a_dialog *info )
{
    a_list          *list = NULL;
    a_combo_box     *combo;

    VSCREEN     *vs;
    SAREA       area;
    VFIELD      *fld;

    fld = info->curr;

    if( fld->typ == FLD_PULLDOWN ) {
        list = fld->ptr;
    } else if( fld->typ == FLD_COMBOBOX ) {
        combo = fld->ptr;
        list = &combo->list;
    }
    if( list->get == NULL ) {
        list->get = ( bool (*) ( void *, unsigned, char *, unsigned ) )
                        uigetlistelement;       // set get_element function
    }
    switch( ev ) {
    case EV_MOUSE_DCLICK:
    case EV_MOUSE_PRESS:
    {
        ORD             row, col;

        uivmousepos( info->vs, &row, &col );
        area = fld->area;
        area.width += 1;    /* extra column for button */
        if( fld->typ == FLD_COMBOBOX ) {
            /* mouse press must be on little button at right */
            area.col += area.width;
            area.width = 1;
        }
        if( fld->typ == FLD_COMBOBOX || fld->typ == FLD_PULLDOWN ) {
            /* mouse press must be on top line */
            area.height = 1;
        }
        if( row < area.row  || row >= area.row + area.height ) break;
        if( col < area.col  || col >= area.col + area.width ) break;
        /* FALLS into next case */
    }
    case EV_CURSOR_DOWN:
    case EV_ALT_CURSOR_DOWN:
        /* list->box must be null */
        area = fld->area;
        vs   = info->vs;
        area.row += ( vs->area.row + 2 );
        area.col += vs->area.col;
        if( fld->typ == FLD_COMBOBOX ) {
            area.col++;
        }
        if( area.row + area.height >= UIData->height ) {
            area.row -= area.height + 3;
        }
        vs = uiopen( &area, NULL, V_DIALOGUE | V_LISTBOX );
        area.row = 0;
        area.col = 0;
        list->box = uibeglistbox( vs, &area, list );
        if( ev != EV_MOUSE_PRESS && ev != EV_MOUSE_DCLICK
                        && fld->typ == FLD_COMBOBOX ) {
            info->dirty = TRUE;
            setcombobuffer( info, fld );
            print_field( info->vs, fld, TRUE );
        }
        break;
    }
    return( ev );
}
Example #30
0
error_code_t print_mem(lnf_mem_t *mem, size_t limit)
{
        lnf_rec_t *rec; //record = line
        size_t rec_cntr = 0; //aka lines counter

        lnf_mem_cursor_t *cursor; //current record (line) cursor
        size_t fld_max_size = 0; //maximum data size length in bytes
        size_t data_max_strlen[LNF_FLD_TERM_] = {0}; //maximum data string len


        if (output_params.print_records != OUTPUT_ITEM_YES) {
                return E_OK;
        }
        first_item = first_item ? false : (putchar('\n'), false);

        secondary_errno = lnf_rec_init(&rec);
        if (secondary_errno != LNF_OK) {
                print_err(E_LNF, secondary_errno, "lnf_rec_init()");
                return E_LNF;
        }


        /*
         * Find out maximum data type size of present fields, length of headers
         * and last present field ID.
         */
        for (size_t i = 0; i < fields_cnt; ++i) {
                size_t header_str_len = strlen(field_get_name(fields[i].id));

                MAX_ASSIGN(fld_max_size, fields[i].size);
                MAX_ASSIGN(data_max_strlen[fields[i].id], header_str_len);
        }

        /* Find out max data length, converted to string. */
        lnf_mem_first_c(mem, &cursor);
        while (cursor != NULL) { //row loop
                char buff[fld_max_size];

                lnf_mem_read_c(mem, cursor, rec);

                for (size_t i = 0; i < fields_cnt; ++i) { //column loop
                        size_t data_str_len;

                        //XXX: lnf_rec_fget() may return LNF_ERR_UNKFLD even if
                        //field is present (e.g. if duration is zero).
                        lnf_rec_fget(rec, fields[i].id, buff);
                        data_str_len = strlen(field_to_str(fields[i].id, buff));
                        MAX_ASSIGN(data_max_strlen[fields[i].id], data_str_len);
                }

                if (++rec_cntr == limit) {
                        break;
                }

                lnf_mem_next_c(mem, &cursor);
        }
        rec_cntr = 0;


        /* Actual printing: header. */
        for (size_t i = 0; i < fields_cnt; ++i) { //column loop
                print_field(field_get_name(fields[i].id),
                                data_max_strlen[fields[i].id],
                                PRETTY_PRINT_COL_WIDTH, i == (fields_cnt - 1));
        }

        /* Actual printing: field data converted to string. */
        lnf_mem_first_c(mem, &cursor);
        while (cursor != NULL) { //row loop
                char buff[fld_max_size];

                lnf_mem_read_c(mem, cursor, rec);

                for (size_t i = 0; i < fields_cnt; ++i) { //column loop
                        //XXX: see above lnf_rec_fget()
                        lnf_rec_fget(rec, fields[i].id, buff);

                        print_field(field_to_str(fields[i].id, buff),
                                        data_max_strlen[fields[i].id],
                                        PRETTY_PRINT_COL_WIDTH,
                                        i == (fields_cnt - 1));
                }

                if (++rec_cntr == limit) {
                        break;
                }

                lnf_mem_next_c(mem, &cursor);
        }

        lnf_rec_free(rec);

        return E_OK;
}