int
rdmasniff_findalldevs(pcap_if_list_t *devlistp, char *err_str)
{
struct ibv_device **dev_list;
int numdev;
int i;
int ret = 0;
dev_list = ibv_get_device_list(&numdev);
if (!dev_list || !numdev) {
return 0;
}
for (i = 0; i < numdev; ++i) {
/*
* XXX - do the notions of "up", "running", or
* "connected" apply here?
*/
if (!add_dev(devlistp, dev_list[i]->name, 0, "RDMA sniffer", err_str)) {
ret = -1;
goto out;
}
}
out:
ibv_free_device_list(dev_list);
return ret;
}
int
pcap_platform_finddevs(pcap_if_list_t *devlistp, char *errbuf)
{
#ifdef HAVE_SOLARIS
int fd;
union {
u_int nunits;
char pad[516]; /* XXX - must be at least 513; is 516
in "atmgetunits" */
} buf;
char baname[2+1+1];
u_int i;
#endif
/*
* Get the list of regular interfaces first.
*/
if (pcap_findalldevs_interfaces(devlistp, errbuf, is_dlpi_interface) == -1)
return (-1); /* failure */
#ifdef HAVE_SOLARIS
/*
* We may have to do special magic to get ATM devices.
*/
if ((fd = open("/dev/ba", O_RDWR)) < 0) {
/*
* We couldn't open the "ba" device.
* For now, just give up; perhaps we should
* return an error if the problem is neither
* a "that device doesn't exist" error (ENOENT,
* ENXIO, etc.) or a "you're not allowed to do
* that" error (EPERM, EACCES).
*/
return (0);
}
if (strioctl(fd, A_GET_UNITS, sizeof(buf), (char *)&buf) < 0) {
pcap_snprintf(errbuf, PCAP_ERRBUF_SIZE, "A_GET_UNITS: %s",
pcap_strerror(errno));
return (-1);
}
for (i = 0; i < buf.nunits; i++) {
pcap_snprintf(baname, sizeof baname, "ba%u", i);
if (add_dev(devlistp, baname, 0, NULL, errbuf) == NULL)
return (-1);
}
#endif
return (0);
}
/* API: refresh the device list */
static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f)
{
struct alsa_factory *af = (struct alsa_factory*)f;
char **hints, **n;
int err;
TRACE_((THIS_FILE, "pjmedia_snd_init: Enumerate sound devices"));
if (af->pool != NULL) {
pj_pool_release(af->pool);
af->pool = NULL;
}
af->pool = pj_pool_create(af->pf, "alsa_aud", 256, 256, NULL);
af->dev_cnt = 0;
/* Enumerate sound devices */
err = snd_device_name_hint(-1, "pcm", (void***)&hints);
if (err != 0)
return PJMEDIA_EAUD_SYSERR;
/* Set a null error handler prior to enumeration to suppress errors */
snd_lib_error_set_handler(null_alsa_error_handler);
n = hints;
while (*n != NULL) {
char *name = snd_device_name_get_hint(*n, "NAME");
if (name != NULL) {
if (0 != strcmp("null", name))
add_dev(af, name);
free(name);
}
n++;
}
/* Get the mixer name */
get_mixer_name(af);
/* Install error handler after enumeration, otherwise we'll get many
* error messages about invalid card/device ID.
*/
snd_lib_error_set_handler(alsa_error_handler);
err = snd_device_name_free_hint((void**)hints);
PJ_LOG(4,(THIS_FILE, "ALSA driver found %d devices", af->dev_cnt));
return PJ_SUCCESS;
}
/* facility to add an USB device to the device list*/
static int
usb_dev_add(pcap_if_list_t *devlistp, int n, char *err_str)
{
char dev_name[10];
char dev_descr[30];
pcap_snprintf(dev_name, 10, USB_IFACE"%d", n);
if (n == 0)
pcap_snprintf(dev_descr, 30, "All USB buses");
else
pcap_snprintf(dev_descr, 30, "USB bus number %d", n);
if (add_dev(devlistp, dev_name, 0, dev_descr, err_str) == NULL)
return -1;
return 0;
}
void wlan_proc(u_char *buf) {
/* TODO: Make time function */
/************ Note ********************
* Was getting strange packets, could *
* not interpret them correctly. This *
* way of parsing (tree parsing?) *
* probably isn't the best... Email me*
* with suggestions or ideas. Thanks! *
*************************************/
if (buf[2]>50) {
//printf("Strange! %02x\n",buf[2]);
//g_printf("mac:%s\n",get_src_mac(buf));
return;
}
//printf("Good! %02x\n",buf[2]);
/**************************************
* Get the input mac, then send it to *
* the add_dev function so it can add *
* it and perform other processing. *
* add_dev returns a pointer to the *
* device struct that we can fill. *
**************************************/
gchar *input_mac = get_src_mac(buf);
device *cdev = add_dev(input_mac);
/* Now fill the device struct with *
* more information from the packet */
/* Time */
time_t btime;
struct tm *time_s;
time(&btime);
time_s=localtime(&btime);
cdev->time=asctime(time_s);
cdev->time[24]=0x00;
/* Probes (will be specific to packet types) */
//g_scanf(cdev->probes,"none");
cdev->probes[0]=0x00;
return;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
QTextCodec::setCodecForTr(QTextCodec::codecForName ("Windows-1251"));
// configure scroll bars:
// Since scroll bars only support integer values, we'll set a high default range of -500..500 and
// divide scroll bar position values by 100 to provide a scroll range -5..5 in floating point
// axis coordinates. if you want to dynamically grow the range accessible with the scroll bar,
// just increase the the minimum/maximum values of the scroll bars as needed.
/* ui->horizontalScrollBar->setRange(0, 5000);
ui->verticalScrollBar->setRange(-500, 500);
// create connection between axes and scroll bars:
connect(ui->horizontalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(horzScrollBarChanged(int)));
connect(ui->verticalScrollBar, SIGNAL(valueChanged(int)), this, SLOT(vertScrollBarChanged(int)));
connect(ui->plot->xAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(xAxisChanged(QCPRange)));
connect(ui->plot->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(yAxisChanged(QCPRange)));
// initialize axis range (and scroll bar positions via signals we just connected):
//ui->plot->xAxis->setRange(0, 10, Qt::AlignLeft);
ui->plot->xAxis->setRange(0, 10, Qt::AlignLeft);
// ui->plot->yAxis->setRange(0, 10, Qt::AlignLeft);
ui->plot->axisRect()->setupFullAxesBox(true);
//QMargins m(0,10,0,10);
//ui->plot->axisRect()->setMargins(m);
ui->plot->axisRect()->autoMargins();
ui->plot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
ui->horizontalScrollBar->setValue(0);
*/
commuter = new cls_Communicator();
connect(ui->AddDevButton, SIGNAL(clicked()), commuter, SLOT(add_dev()));
connect(ui->scanButton, SIGNAL(clicked()), commuter, SLOT(detect_devlist()));
connect(ui->OptionsAction, SIGNAL(triggered()), this, SLOT(view_options_dialog()));
connect(commuter, SIGNAL(send_senslist(std::list<cls_Sensor*>)), ui->dev_tree, SLOT(set_dev_list(std::list<cls_Sensor*>)));
}
int parport_daisy_init(struct parport *port)
{
int detected = 0;
char *deviceid;
static const char *th[] = { "th", "st", "nd", "rd", "th" };
int num_ports;
int i;
int last_try = 0;
again:
if (port->muxport < 0 && mux_present(port) &&
((num_ports = num_mux_ports(port)) == 2 || num_ports == 4)) {
port->muxport = 0;
printk(KERN_INFO
"%s: 1st (default) port of %d-way multiplexor\n",
port->name, num_ports);
for (i = 1; i < num_ports; i++) {
struct parport *extra = clone_parport(port, i);
if (!extra) {
if (signal_pending(current))
break;
schedule();
continue;
}
printk(KERN_INFO
"%s: %d%s port of %d-way multiplexor on %s\n",
extra->name, i + 1, th[i + 1], num_ports,
port->name);
parport_daisy_init(extra);
}
}
if (port->muxport >= 0)
select_port(port);
parport_daisy_deselect_all(port);
detected += assign_addrs(port);
add_dev(numdevs++, port, -1);
deviceid = kmalloc(1024, GFP_KERNEL);
if (deviceid) {
if (parport_device_id(numdevs - 1, deviceid, 1024) > 2)
detected++;
kfree(deviceid);
}
if (!detected && !last_try) {
parport_daisy_fini(port);
parport_write_control(port, PARPORT_CONTROL_SELECT);
udelay(50);
parport_write_control(port,
PARPORT_CONTROL_SELECT |
PARPORT_CONTROL_INIT);
udelay(50);
last_try = 1;
goto again;
}
return detected;
}
static int assign_addrs(struct parport *port)
{
unsigned char s;
unsigned char daisy;
int thisdev = numdevs;
int detected;
char *deviceid;
parport_data_forward(port);
parport_write_data(port, 0xaa); udelay(2);
parport_write_data(port, 0x55); udelay(2);
parport_write_data(port, 0x00); udelay(2);
parport_write_data(port, 0xff); udelay(2);
s = parport_read_status(port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR)) {
DPRINTK(KERN_DEBUG "%s: assign_addrs: aa5500ff(%02x)\n",
port->name, s);
return 0;
}
parport_write_data(port, 0x87); udelay(2);
s = parport_read_status(port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) {
DPRINTK(KERN_DEBUG "%s: assign_addrs: aa5500ff87(%02x)\n",
port->name, s);
return 0;
}
parport_write_data(port, 0x78); udelay(2);
s = parport_read_status(port);
for (daisy = 0;
(s & (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT))
== (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT)
&& daisy < 4;
++daisy) {
parport_write_data(port, daisy);
udelay(2);
parport_frob_control(port,
PARPORT_CONTROL_STROBE,
PARPORT_CONTROL_STROBE);
udelay(1);
parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
udelay(1);
add_dev(numdevs++, port, daisy);
if (!(s & PARPORT_STATUS_BUSY))
break;
s = parport_read_status(port);
}
parport_write_data(port, 0xff); udelay(2);
detected = numdevs - thisdev;
DPRINTK(KERN_DEBUG "%s: Found %d daisy-chained devices\n", port->name,
detected);
deviceid = kmalloc(1024, GFP_KERNEL);
if (!deviceid) return 0;
for (daisy = 0; thisdev < numdevs; thisdev++, daisy++)
parport_device_id(thisdev, deviceid, 1024);
kfree(deviceid);
return detected;
}
int parport_daisy_init(struct parport *port)
{
int detected = 0;
char *deviceid;
static const char *th[] = { /*0*/"th", "st", "nd", "rd", "th" };
int num_ports;
int i;
int last_try = 0;
again:
/* Because this is called before any other devices exist,
* we don't have to claim exclusive access. */
/* If mux present on normal port, need to create new
* parports for each extra port. */
if (port->muxport < 0 && mux_present(port) &&
/* don't be fooled: a mux must have 2 or 4 ports. */
((num_ports = num_mux_ports(port)) == 2 || num_ports == 4)) {
/* Leave original as port zero. */
port->muxport = 0;
printk(KERN_INFO
"%s: 1st (default) port of %d-way multiplexor\n",
port->name, num_ports);
for (i = 1; i < num_ports; i++) {
/* Clone the port. */
struct parport *extra = clone_parport(port, i);
if (!extra) {
if (signal_pending(current))
break;
schedule();
continue;
}
printk(KERN_INFO
"%s: %d%s port of %d-way multiplexor on %s\n",
extra->name, i + 1, th[i + 1], num_ports,
port->name);
/* Analyse that port too. We won't recurse
forever because of the 'port->muxport < 0'
test above. */
parport_daisy_init(extra);
}
}
if (port->muxport >= 0)
select_port(port);
parport_daisy_deselect_all(port);
detected += assign_addrs(port);
/* Count the potential legacy device at the end. */
add_dev(numdevs++, port, -1);
/* Find out the legacy device's IEEE 1284 device ID. */
deviceid = kmalloc(1024, GFP_KERNEL);
if (deviceid) {
if (parport_device_id(numdevs - 1, deviceid, 1024) > 2)
detected++;
kfree(deviceid);
}
if (!detected && !last_try) {
/* No devices were detected. Perhaps they are in some
funny state; let's try to reset them and see if
they wake up. */
parport_daisy_fini(port);
parport_write_control(port, PARPORT_CONTROL_SELECT);
udelay(50);
parport_write_control(port,
PARPORT_CONTROL_SELECT |
PARPORT_CONTROL_INIT);
udelay(50);
last_try = 1;
goto again;
}
return detected;
}
static int assign_addrs(struct parport *port)
{
unsigned char s;
unsigned char daisy;
int thisdev = numdevs;
int detected;
char *deviceid;
parport_data_forward(port);
parport_write_data(port, 0xaa); udelay(2);
parport_write_data(port, 0x55); udelay(2);
parport_write_data(port, 0x00); udelay(2);
parport_write_data(port, 0xff); udelay(2);
s = parport_read_status(port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR)) {
DPRINTK(KERN_DEBUG "%s: assign_addrs: aa5500ff(%02x)\n",
port->name, s);
return 0;
}
parport_write_data(port, 0x87); udelay(2);
s = parport_read_status(port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) {
DPRINTK(KERN_DEBUG "%s: assign_addrs: aa5500ff87(%02x)\n",
port->name, s);
return 0;
}
parport_write_data(port, 0x78); udelay(2);
s = parport_read_status(port);
for (daisy = 0;
(s & (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT))
== (PARPORT_STATUS_PAPEROUT|PARPORT_STATUS_SELECT)
&& daisy < 4;
++daisy) {
parport_write_data(port, daisy);
udelay(2);
parport_frob_control(port,
PARPORT_CONTROL_STROBE,
PARPORT_CONTROL_STROBE);
udelay(1);
parport_frob_control(port, PARPORT_CONTROL_STROBE, 0);
udelay(1);
add_dev(numdevs++, port, daisy);
/* See if this device thought it was the last in the
* chain. */
if (!(s & PARPORT_STATUS_BUSY))
break;
/* We are seeing pass through status now. We see
last_dev from next device or if last_dev does not
work status lines from some non-daisy chain
device. */
s = parport_read_status(port);
}
parport_write_data(port, 0xff); udelay(2);
detected = numdevs - thisdev;
DPRINTK(KERN_DEBUG "%s: Found %d daisy-chained devices\n", port->name,
detected);
/* Ask the new devices to introduce themselves. */
deviceid = kmalloc(1024, GFP_KERNEL);
if (!deviceid) return 0;
for (daisy = 0; thisdev < numdevs; thisdev++, daisy++)
parport_device_id(thisdev, deviceid, 1024);
kfree(deviceid);
return detected;
}
int
append(void)
{
ARCHD *arcn;
int res;
FSUB *orgfrmt;
int udev;
off_t tlen;
arcn = &archd;
orgfrmt = frmt;
/*
* Do not allow an append operation if the actual archive is of a
* different format than the user specified format.
*/
if (get_arc() < 0)
return 1;
if ((orgfrmt != NULL) && (orgfrmt != frmt)) {
tty_warn(1, "Cannot mix current archive format %s with %s",
frmt->name, orgfrmt->name);
return 1;
}
/*
* pass the format any options and start up format
*/
if (((*frmt->options)() < 0) || ((*frmt->st_rd)() < 0))
return 1;
/*
* if we only are adding members that are newer, we need to save the
* mod times for all files we see.
*/
if (uflag && (ftime_start() < 0))
return 1;
/*
* some archive formats encode hard links by recording the device and
* file serial number (inode) but copy the file anyway (multiple times)
* to the archive. When we append, we run the risk that newly added
* files may have the same device and inode numbers as those recorded
* on the archive but during a previous run. If this happens, when the
* archive is extracted we get INCORRECT hard links. We avoid this by
* remapping the device numbers so that newly added files will never
* use the same device number as one found on the archive. remapping
* allows new members to safely have links among themselves. remapping
* also avoids problems with file inode (serial number) truncations
* when the inode number is larger than storage space in the archive
* header. See the remap routines for more details.
*/
if ((udev = frmt->udev) && (dev_start() < 0))
return 1;
/*
* reading the archive may take a long time. If verbose tell the user
*/
if (vflag || Vflag) {
(void)fprintf(listf,
"%s: Reading archive to position at the end...", argv0);
vfpart = 1;
}
/*
* step through the archive until the format says it is done
*/
while (next_head(arcn) == 0) {
/*
* check if this file meets user specified options.
*/
if (sel_chk(arcn) != 0) {
if (rd_skip(arcn->skip + arcn->pad) == 1)
break;
continue;
}
if (uflag) {
/*
* see if this is the newest version of this file has
* already been seen, if so skip.
*/
if ((res = chk_ftime(arcn)) < 0)
break;
if (res > 0) {
if (rd_skip(arcn->skip + arcn->pad) == 1)
break;
continue;
}
}
/*
* Store this device number. Device numbers seen during the
* read phase of append will cause newly appended files with a
* device number seen in the old part of the archive to be
* remapped to an unused device number.
*/
if ((udev && (add_dev(arcn) < 0)) ||
(rd_skip(arcn->skip + arcn->pad) == 1))
break;
}
/*
* done, finish up read and get the number of bytes to back up so we
* can add new members. The format might have used the hard link table,
* purge it.
*/
tlen = (*frmt->end_rd)();
lnk_end();
/*
* try to position for write, if this fails quit. if any error occurs,
* we will refuse to write
*/
if (appnd_start(tlen) < 0)
return 1;
/*
* tell the user we are done reading.
*/
if ((vflag || Vflag) && vfpart) {
(void)safe_print("done.\n", listf);
vfpart = 0;
}
/*
* go to the writing phase to add the new members
*/
res = wr_archive(arcn, 1);
if (res == 1) {
/*
* wr_archive failed in some way, but before any files were
* added. These are the only steps needed to cleanup (and
* not truncate the archive).
*/
wr_fin();
(void)sigprocmask(SIG_BLOCK, &s_mask, (sigset_t *)NULL);
ar_close();
}
return res;
}
int init_devices(struct fpga_model* model)
{
int x, y, i, j, rc;
RC_CHECK(model);
// DCM, PLL
for (i = 0; i < model->die->num_rows; i++) {
y = TOP_IO_TILES + HALF_ROW-1 + i*ROW_SIZE;
if (y > model->center_y) y++; // central regs
x = model->center_x-CENTER_CMTPLL_O;
if (i%2) {
if ((rc = add_dev(model, y, x, DEV_DCM, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_DCM, 0))) goto fail;
} else
if ((rc = add_dev(model, y, x, DEV_PLL, 0))) goto fail;
}
// BSCAN
y = TOP_IO_TILES;
x = model->x_width-RIGHT_IO_DEVS_O;
if ((rc = add_dev(model, y, x, DEV_BSCAN, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BSCAN, 0))) goto fail;
// BSCAN, OCT_CALIBRATE
y = TOP_IO_TILES+1;
x = model->x_width-RIGHT_IO_DEVS_O;
if ((rc = add_dev(model, y, x, DEV_BSCAN, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BSCAN, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_OCT_CALIBRATE, 0))) goto fail;
// ICAP, SPI_ACCESS, OCT_CALIBRATE
y = model->y_height-BOT_IO_TILES-1;
x = model->x_width-RIGHT_IO_DEVS_O;
if ((rc = add_dev(model, y, x, DEV_ICAP, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_SPI_ACCESS, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_OCT_CALIBRATE, 0))) goto fail;
// STARTUP, POST_CRC_INTERNAL, SLAVE_SPI, SUSPEND_SYNC
y = model->y_height-BOT_IO_TILES-2;
x = model->x_width-RIGHT_IO_DEVS_O;
if ((rc = add_dev(model, y, x, DEV_STARTUP, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_POST_CRC_INTERNAL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_SLAVE_SPI, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_SUSPEND_SYNC, 0))) goto fail;
// MCB
if ((rc = add_dev(model, model->die->mcb_ypos, LEFT_MCB_COL, DEV_MCB, 0))) goto fail;
if ((rc = add_dev(model, model->die->mcb_ypos, model->x_width-RIGHT_MCB_O, DEV_MCB, 0))) goto fail;
// OCT_CALIBRATE
x = LEFT_IO_DEVS;
if ((rc = add_dev(model, TOP_IO_TILES, x, DEV_OCT_CALIBRATE, 0)))
FAIL(rc);
if ((rc = add_dev(model, TOP_IO_TILES, x, DEV_OCT_CALIBRATE, 0)))
FAIL(rc);
if ((rc = add_dev(model, model->y_height-BOT_IO_TILES-1, x,
DEV_OCT_CALIBRATE, 0))) FAIL(rc);
if ((rc = add_dev(model, model->y_height-BOT_IO_TILES-1, x,
DEV_OCT_CALIBRATE, 0))) FAIL(rc);
// DNA, PMV
x = LEFT_IO_DEVS;
y = TOP_IO_TILES;
if ((rc = add_dev(model, y, x, DEV_DNA, 0))) FAIL(rc);
if ((rc = add_dev(model, y, x, DEV_PMV, 0))) FAIL(rc);
// PCILOGIC_SE
if ((rc = add_dev(model, model->center_y, LEFT_IO_ROUTING,
DEV_PCILOGIC_SE, 0))) FAIL(rc);
if ((rc = add_dev(model, model->center_y, model->x_width
- RIGHT_IO_DEVS_O, DEV_PCILOGIC_SE, 0))) FAIL(rc);
// BUFGMUX
y = model->center_y;
x = model->center_x;
for (i = 0; i < 16; i++)
if ((rc = add_dev(model, y, x, DEV_BUFGMUX, 0))) goto fail;
// BUFIO, BUFIO_FB, BUFPLL, BUFPLL_MCB
y = TOP_OUTER_ROW;
x = model->center_x-CENTER_CMTPLL_O;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL_MCB, 0))) goto fail;
for (j = 0; j < 8; j++) {
if ((rc = add_dev(model, y, x, DEV_BUFIO, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFIO_FB, 0))) goto fail;
}
y = model->center_y;
x = LEFT_OUTER_COL;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL_MCB, 0))) goto fail;
for (j = 0; j < 8; j++) {
if ((rc = add_dev(model, y, x, DEV_BUFIO, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFIO_FB, 0))) goto fail;
}
y = model->center_y;
x = model->x_width - RIGHT_OUTER_O;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL_MCB, 0))) goto fail;
for (j = 0; j < 8; j++) {
if ((rc = add_dev(model, y, x, DEV_BUFIO, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFIO_FB, 0))) goto fail;
}
y = model->y_height - BOT_OUTER_ROW;
x = model->center_x-CENTER_CMTPLL_O;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFPLL_MCB, 0))) goto fail;
for (j = 0; j < 8; j++) {
if ((rc = add_dev(model, y, x, DEV_BUFIO, 0))) goto fail;
if ((rc = add_dev(model, y, x, DEV_BUFIO_FB, 0))) goto fail;
}
// BUFH
for (i = 0; i < model->die->num_rows; i++) {
y = TOP_IO_TILES + HALF_ROW + i*ROW_SIZE;
if (y > model->center_y) y++; // central regs
x = model->center_x;
for (j = 0; j < 32; j++)
if ((rc = add_dev(model, y, x, DEV_BUFH, 0))) goto fail;
}
// BRAM
for (x = 0; x < model->x_width; x++) {
if (!is_atx(X_FABRIC_BRAM_COL, model, x))
continue;
for (y = TOP_IO_TILES; y < model->y_height-BOT_IO_TILES; y++) {
if (!(YX_TILE(model, y, x)->flags & TF_BRAM_DEV))
continue;
if ((rc = add_dev(model, y, x, DEV_BRAM16, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_BRAM8, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_BRAM8, 0)))
goto fail;
}
}
// MACC
for (x = 0; x < model->x_width; x++) {
if (!is_atx(X_FABRIC_MACC_COL, model, x))
continue;
for (y = TOP_IO_TILES; y < model->y_height-BOT_IO_TILES; y++) {
if (!(YX_TILE(model, y, x)->flags & TF_MACC_DEV))
continue;
if ((rc = add_dev(model, y, x, DEV_MACC, 0))) goto fail;
}
}
// ILOGIC/OLOGIC/IODELAY
for (x = LEFT_SIDE_WIDTH; x < model->x_width - RIGHT_SIDE_WIDTH; x++) {
if (!is_atx(X_FABRIC_LOGIC_COL|X_CENTER_LOGIC_COL, model, x)
|| is_atx(X_ROUTING_NO_IO, model, x-1))
continue;
for (i = 0; i <= 1; i++) {
y = TOP_IO_TILES+i;
for (j = 0; j <= 1; j++) {
if ((rc = add_dev(model, y, x, DEV_ILOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_OLOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_IODELAY, 0)))
goto fail;
}
y = model->y_height-BOT_IO_TILES-i-1;
for (j = 0; j <= 1; j++) {
if ((rc = add_dev(model, y, x, DEV_ILOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_OLOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_IODELAY, 0)))
goto fail;
}
}
}
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (is_aty(Y_LEFT_WIRED, model, y)) {
x = LEFT_IO_DEVS;
for (j = 0; j <= 1; j++) {
if ((rc = add_dev(model, y, x, DEV_ILOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_OLOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_IODELAY, 0)))
goto fail;
}
}
if (is_aty(Y_RIGHT_WIRED, model, y)) {
x = model->x_width-RIGHT_IO_DEVS_O;
for (j = 0; j <= 1; j++) {
if ((rc = add_dev(model, y, x, DEV_ILOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_OLOGIC, 0)))
goto fail;
if ((rc = add_dev(model, y, x, DEV_IODELAY, 0)))
goto fail;
}
}
}
// IOB
for (x = 0; x < model->x_width; x++) {
// Note that the order of sub-types IOBM and IOBS must match
// the order in the control.c sitename arrays.
if (is_atx(X_OUTER_LEFT, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (!is_aty(Y_LEFT_WIRED, model, y))
continue;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
}
}
if (is_atx(X_OUTER_RIGHT, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (!is_aty(Y_RIGHT_WIRED, model, y))
continue;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
}
}
if (is_atx(X_FABRIC_LOGIC_ROUTING_COL|X_CENTER_ROUTING_COL, model, x)
&& !is_atx(X_ROUTING_NO_IO, model, x)) {
y = TOP_OUTER_ROW;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
y = model->y_height-BOT_OUTER_ROW;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBS))) goto fail;
if ((rc = add_dev(model, y, x, DEV_IOB, IOBM))) goto fail;
}
}
// TIEOFF
y = model->center_y;
x = LEFT_OUTER_COL;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
y = model->center_y;
x = model->x_width-RIGHT_OUTER_O;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
y = TOP_OUTER_ROW;
x = model->center_x-1;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
y = model->y_height-BOT_OUTER_ROW;
x = model->center_x-CENTER_CMTPLL_O;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
for (x = 0; x < model->x_width; x++) {
if (is_atx(X_LEFT_IO_DEVS_COL, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (!is_aty(Y_LEFT_WIRED, model, y))
continue;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
}
}
if (is_atx(X_RIGHT_IO_DEVS_COL, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (!is_aty(Y_RIGHT_WIRED, model, y))
continue;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
}
}
if (is_atx(X_CENTER_CMTPLL_COL, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (!(YX_TILE(model, y, x)->flags & TF_PLL_DEV))
continue;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
}
}
if (is_atx(X_ROUTING_COL, model, x)) {
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
if (is_aty(Y_ROW_HORIZ_AXSYMM|Y_CHIP_HORIZ_REGS,
model, y))
continue;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
}
}
if (is_atx(X_FABRIC_LOGIC_COL|X_CENTER_LOGIC_COL, model, x)
&& !is_atx(X_ROUTING_NO_IO, model, x-1)) {
for (i = 0; i <= 1; i++) {
y = TOP_IO_TILES+i;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
y = model->y_height-BOT_IO_TILES-i-1;
if ((rc = add_dev(model, y, x, DEV_TIEOFF, 0))) goto fail;
}
}
}
// LOGIC
for (x = 0; x < model->x_width; x++) {
if (!is_atx(X_FABRIC_LOGIC_COL|X_CENTER_LOGIC_COL, model, x))
continue;
for (y = TOP_IO_TILES; y < model->y_height - BOT_IO_TILES; y++) {
// M and L are at index 0 (DEV_LOG_M_OR_L),
// X is at index 1 (DEV_LOG_X).
if (YX_TILE(model, y, x)->flags & TF_LOGIC_XM_DEV) {
if ((rc = add_dev(model, y, x, DEV_LOGIC, LOGIC_M))) goto fail;
if ((rc = add_dev(model, y, x, DEV_LOGIC, LOGIC_X))) goto fail;
}
if (YX_TILE(model, y, x)->flags & TF_LOGIC_XL_DEV) {
if ((rc = add_dev(model, y, x, DEV_LOGIC, LOGIC_L))) goto fail;
if ((rc = add_dev(model, y, x, DEV_LOGIC, LOGIC_X))) goto fail;
}
}
}
return 0;
fail:
return rc;
}
/* API: refresh the device list */
static pj_status_t alsa_factory_refresh(pjmedia_aud_dev_factory *f)
{
struct alsa_factory *af = (struct alsa_factory*)f;
char **hints, **n;
int err;
TRACE_((THIS_FILE, "pjmedia_snd_init: Enumerate sound devices"));
if (af->pool != NULL) {
pj_pool_release(af->pool);
af->pool = NULL;
}
af->pool = pj_pool_create(af->pf, "alsa_aud", 256, 256, NULL);
af->dev_cnt = 0;
/* Enumerate sound devices */
err = snd_device_name_hint(-1, "pcm", (void***)&hints);
if (err != 0)
return PJMEDIA_EAUD_SYSERR;
/* Set a null error handler prior to enumeration to suppress errors */
snd_lib_error_set_handler(null_alsa_error_handler);
n = hints;
while (*n != NULL) {
char *name = snd_device_name_get_hint(*n, "NAME");
char *desc = snd_device_name_get_hint(*n, "DESC");
if (name != NULL) {
if (strncmp("null", name, 4) == 0 ||
strncmp("front", name, 5) == 0 ||
strncmp("rear", name, 4) == 0 ||
strncmp("side", name, 4) == 0 ||
strncmp("dmix", name, 4) == 0 ||
strncmp("dsnoop", name, 6) == 0 ||
strncmp("hw", name, 2) == 0 ||
strncmp("plughw", name, 6) == 0 ||
strncmp("center_lfe", name, 10) == 0 ||
strncmp("surround40", name, 10) == 0 ||
strncmp("surround41", name, 10) == 0 ||
strncmp("surround50", name, 10) == 0 ||
strncmp("surround51", name, 10) == 0 ||
strncmp("surround71", name, 10) == 0 ||
(strncmp("default", name, 7) == 0 && strstr(name, ":CARD=") != NULL)) {
/* skip these devices, 'sysdefault' always contains the relevant information */
;
} else {
add_dev(af, name, desc);
}
free(name);
free(desc);
}
n++;
}
/* Install error handler after enumeration, otherwise we'll get many
* error messages about invalid card/device ID.
*/
snd_lib_error_set_handler(alsa_error_handler);
err = snd_device_name_free_hint((void**)hints);
PJ_LOG(4,(THIS_FILE, "ALSA driver found %d devices", af->dev_cnt));
return PJ_SUCCESS;
}
int
bt_findalldevs(pcap_if_list_t *devlistp, char *err_str)
{
struct hci_dev_list_req *dev_list;
struct hci_dev_req *dev_req;
int i, sock;
int ret = 0;
sock = socket(AF_BLUETOOTH, SOCK_RAW, BTPROTO_HCI);
if (sock < 0)
{
/* if bluetooth is not supported this this is not fatal*/
if (errno == EAFNOSUPPORT)
return 0;
pcap_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
errno, "Can't open raw Bluetooth socket");
return -1;
}
dev_list = malloc(HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
if (!dev_list)
{
pcap_snprintf(err_str, PCAP_ERRBUF_SIZE, "Can't allocate %zu bytes for Bluetooth device list",
HCI_MAX_DEV * sizeof(*dev_req) + sizeof(*dev_list));
ret = -1;
goto done;
}
dev_list->dev_num = HCI_MAX_DEV;
if (ioctl(sock, HCIGETDEVLIST, (void *) dev_list) < 0)
{
pcap_fmt_errmsg_for_errno(err_str, PCAP_ERRBUF_SIZE,
errno, "Can't get Bluetooth device list via ioctl");
ret = -1;
goto free;
}
dev_req = dev_list->dev_req;
for (i = 0; i < dev_list->dev_num; i++, dev_req++) {
char dev_name[20], dev_descr[30];
pcap_snprintf(dev_name, 20, BT_IFACE"%d", dev_req->dev_id);
pcap_snprintf(dev_descr, 30, "Bluetooth adapter number %d", i);
/*
* Bluetooth is a wireless technology.
* XXX - if there's the notion of associating with a
* network, and we can determine whether the interface
* is associated with a network, check that and set
* the status to PCAP_IF_CONNECTION_STATUS_CONNECTED
* or PCAP_IF_CONNECTION_STATUS_DISCONNECTED.
*/
if (add_dev(devlistp, dev_name, PCAP_IF_WIRELESS, dev_descr, err_str) == NULL)
{
ret = -1;
break;
}
}
free:
free(dev_list);
done:
close(sock);
return ret;
}
static int assign_addrs (struct parport *port)
{
unsigned char s, last_dev;
unsigned char daisy;
int thisdev = numdevs;
int detected;
char *deviceid;
parport_data_forward (port);
parport_write_data (port, 0xaa); udelay (2);
parport_write_data (port, 0x55); udelay (2);
parport_write_data (port, 0x00); udelay (2);
parport_write_data (port, 0xff); udelay (2);
s = parport_read_status (port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR)) {
DPRINTK (KERN_DEBUG "%s: assign_addrs: aa5500ff(%02x)\n",
port->name, s);
return 0;
}
parport_write_data (port, 0x87); udelay (2);
s = parport_read_status (port) & (PARPORT_STATUS_BUSY
| PARPORT_STATUS_PAPEROUT
| PARPORT_STATUS_SELECT
| PARPORT_STATUS_ERROR);
if (s != (PARPORT_STATUS_SELECT | PARPORT_STATUS_ERROR)) {
DPRINTK (KERN_DEBUG "%s: assign_addrs: aa5500ff87(%02x)\n",
port->name, s);
return 0;
}
parport_write_data (port, 0x78); udelay (2);
last_dev = 0; /* We've just been speaking to a device, so we
know there must be at least _one_ out there. */
for (daisy = 0; daisy < 4; daisy++) {
parport_write_data (port, daisy);
udelay (2);
parport_frob_control (port,
PARPORT_CONTROL_STROBE,
PARPORT_CONTROL_STROBE);
udelay (1);
parport_frob_control (port, PARPORT_CONTROL_STROBE, 0);
udelay (1);
if (last_dev)
/* No more devices. */
break;
last_dev = !(parport_read_status (port)
& PARPORT_STATUS_BUSY);
add_dev (numdevs++, port, daisy);
}
parport_write_data (port, 0xff); udelay (2);
detected = numdevs - thisdev;
DPRINTK (KERN_DEBUG "%s: Found %d daisy-chained devices\n", port->name,
detected);
/* Ask the new devices to introduce themselves. */
deviceid = kmalloc (1000, GFP_KERNEL);
if (!deviceid) return 0;
for (daisy = 0; thisdev < numdevs; thisdev++, daisy++)
parport_device_id (thisdev, deviceid, 1000);
kfree (deviceid);
return detected;
}
int add_dev_1(const char *name, const struct stat *stb, int flag)
{
return add_dev(name, stb, flag, NULL);
}
int /* O - Exit code */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
const char *server_bin; /* CUPS_SERVERBIN environment variable */
char backends[1024]; /* Location of backends */
int request_id; /* Request ID */
int count; /* Number of devices from backend */
int compat; /* Compatibility device? */
char *backend_argv[2]; /* Arguments for backend */
cups_file_t *fp; /* Pipe to device backend */
int pid; /* Process ID of backend */
cups_dir_t *dir; /* Directory pointer */
cups_dentry_t *dent; /* Directory entry */
char filename[1024], /* Name of backend */
line[2048], /* Line from backend */
dclass[64], /* Device class */
uri[1024], /* Device URI */
info[128], /* Device info */
make_model[256], /* Make and model */
device_id[1024]; /* 1284 device ID */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
const char *requested; /* requested-attributes option */
int send_class, /* Send device-class attribute? */
send_info, /* Send device-info attribute? */
send_make_and_model, /* Send device-make-and-model attribute? */
send_uri, /* Send device-uri attribute? */
send_id; /* Send device-id attribute? */
dev_info_t *dev; /* Current device */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
setbuf(stderr, NULL);
/*
* Check the command-line...
*/
if (argc > 1)
request_id = atoi(argv[1]);
else
request_id = 1;
if (argc != 5)
{
fputs("Usage: cups-deviced request-id limit user-id options\n", stderr);
return (1);
}
if (request_id < 1)
{
fprintf(stderr, "cups-deviced: Bad request ID %d!\n", request_id);
return (1);
}
normal_user = atoi(argv[3]);
if (normal_user <= 0)
{
fprintf(stderr, "cups-deviced: Bad user %d!\n", normal_user);
return (1);
}
num_options = cupsParseOptions(argv[4], 0, &options);
requested = cupsGetOption("requested-attributes", num_options, options);
if (!requested || strstr(requested, "all"))
{
send_class = 1;
send_info = 1;
send_make_and_model = 1;
send_uri = 1;
send_id = 1;
}
else
{
send_class = strstr(requested, "device-class") != NULL;
send_info = strstr(requested, "device-info") != NULL;
send_make_and_model = strstr(requested, "device-make-and-model") != NULL;
send_uri = strstr(requested, "device-uri") != NULL;
send_id = strstr(requested, "device-id") != NULL;
}
/*
* Try opening the backend directory...
*/
if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
server_bin = CUPS_SERVERBIN;
snprintf(backends, sizeof(backends), "%s/backend", server_bin);
if ((dir = cupsDirOpen(backends)) == NULL)
{
fprintf(stderr, "ERROR: [cups-deviced] Unable to open backend directory "
"\"%s\": %s", backends, strerror(errno));
return (1);
}
/*
* Setup the devices array...
*/
devs = cupsArrayNew((cups_array_func_t)compare_devs, NULL);
/*
* Loop through all of the device backends...
*/
while ((dent = cupsDirRead(dir)) != NULL)
{
/*
* Skip entries that are not executable files...
*/
if (!S_ISREG(dent->fileinfo.st_mode) ||
(dent->fileinfo.st_mode & (S_IRUSR | S_IXUSR)) != (S_IRUSR | S_IXUSR))
continue;
/*
* Change effective users depending on the backend permissions...
*/
snprintf(filename, sizeof(filename), "%s/%s", backends, dent->filename);
/*
* Backends without permissions for normal users run as root,
* all others run as the unprivileged user...
*/
backend_argv[0] = dent->filename;
backend_argv[1] = NULL;
fp = cupsdPipeCommand(&pid, filename, backend_argv,
(dent->fileinfo.st_mode & (S_IRWXG | S_IRWXO))
? normal_user : 0);
/*
* Collect the output from the backend...
*/
if (fp)
{
/*
* Set an alarm for the first read from the backend; this avoids
* problems when a backend is hung getting device information.
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGALRM, sigalrm_handler);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGALRM);
action.sa_handler = sigalrm_handler;
sigaction(SIGALRM, &action, NULL);
#else
signal(SIGALRM, sigalrm_handler);
#endif /* HAVE_SIGSET */
alarm_tripped = 0;
count = 0;
compat = !strcmp(dent->filename, "smb");
alarm(30);
while (cupsFileGets(fp, line, sizeof(line)))
{
/*
* Reset the alarm clock...
*/
alarm(30);
/*
* Each line is of the form:
*
* class URI "make model" "name" ["1284 device ID"]
*/
device_id[0] = '\0';
if (!strncasecmp(line, "Usage", 5))
compat = 1;
else if (sscanf(line,
"%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]\""
"%*[ \t]\"%1023[^\"]",
dclass, uri, make_model, info, device_id) < 4)
{
/*
* Bad format; strip trailing newline and write an error message.
*/
if (line[strlen(line) - 1] == '\n')
line[strlen(line) - 1] = '\0';
fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
dent->filename, line);
compat = 1;
break;
}
else
{
/*
* Add the device to the array of available devices...
*/
dev = add_dev(dclass, make_model, info, uri, device_id);
if (!dev)
{
cupsDirClose(dir);
cupsFileClose(fp);
kill(pid, SIGTERM);
return (1);
}
fprintf(stderr, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
uri);
count ++;
}
}
/*
* Turn the alarm clock off and close the pipe to the command...
*/
alarm(0);
if (alarm_tripped)
fprintf(stderr, "WARNING: [cups-deviced] Backend \"%s\" did not "
"respond within 30 seconds!\n", dent->filename);
cupsFileClose(fp);
kill(pid, SIGTERM);
/*
* Hack for backends that don't support the CUPS 1.1 calling convention:
* add a network device with the method == backend name.
*/
if (count == 0 && compat)
{
snprintf(line, sizeof(line), "Unknown Network Device (%s)",
dent->filename);
dev = add_dev("network", line, "Unknown", dent->filename, "");
if (!dev)
{
cupsDirClose(dir);
return (1);
}
fprintf(stderr, "DEBUG: [cups-deviced] Compatibility device "
"\"%s\"...\n", dent->filename);
}
}
else
fprintf(stderr, "WARNING: [cups-deviced] Unable to execute \"%s\" "
"backend: %s\n", dent->filename, strerror(errno));
}
cupsDirClose(dir);
/*
* Output the list of devices...
*/
puts("Content-Type: application/ipp\n");
cupsdSendIPPHeader(IPP_OK, request_id);
cupsdSendIPPGroup(IPP_TAG_OPERATION);
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
if ((count = atoi(argv[2])) <= 0)
count = cupsArrayCount(devs);
if (count > cupsArrayCount(devs))
count = cupsArrayCount(devs);
for (dev = (dev_info_t *)cupsArrayFirst(devs);
count > 0;
count --, dev = (dev_info_t *)cupsArrayNext(devs))
{
/*
* Add strings to attributes...
*/
cupsdSendIPPGroup(IPP_TAG_PRINTER);
if (send_class)
cupsdSendIPPString(IPP_TAG_KEYWORD, "device-class", dev->device_class);
if (send_info)
cupsdSendIPPString(IPP_TAG_TEXT, "device-info", dev->device_info);
if (send_make_and_model)
cupsdSendIPPString(IPP_TAG_TEXT, "device-make-and-model",
dev->device_make_and_model);
if (send_uri)
cupsdSendIPPString(IPP_TAG_URI, "device-uri", dev->device_uri);
if (send_id)
cupsdSendIPPString(IPP_TAG_TEXT, "device-id", dev->device_id);
}
cupsdSendIPPTrailer();
/*
* Free the devices array and return...
*/
for (dev = (dev_info_t *)cupsArrayFirst(devs);
dev;
dev = (dev_info_t *)cupsArrayNext(devs))
free(dev);
cupsArrayDelete(devs);
return (0);
}
