irdaspray.c

来自「linux操作系统下的红外驱动的测试程序」· C语言 代码 · 共 902 行 · 第 1/2 页

/*********************************************************************
 *                
 * Filename:      irdaspray.c
 * Version:       
 * Description:   
 * Status:        Experimental.
 * Author:        Dag Brattli <[e-mail]>
 *		  Jean Tourrilhes <[e-mail]>
 * Created at:    10/12/99
 * Modified at:   Mon May 10 18:31:35 1999
 * Modified by:   Dag Brattli <[e-mail]>
 * 
 *     Copyright (c) 1999 Dag Brattli, All Rights Reserved.
 *     Copyright (c) 2001 Jean Tourrilhes, All Rights Reserved.
 *     
 *     This program is free software; you can redistribute it and/or 
 *     modify it under the terms of the GNU General Public License as 
 *     published by the Free Software Foundation; either version 2 of 
 *     the License, or (at your option) any later version.
 * 
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *     GNU General Public License for more details.
 * 
 *     You should have received a copy of the GNU General Public License 
 *     along with this program; if not, write to the Free Software 
 *     Foundation, Inc., 59 Temple Place, Suite 330, Boston, 
 *     MA 02111-1307 USA
 *     
 ********************************************************************/

/*
gcc -O2 -Wall -o irdaspray irdaspray.c
*/

/*
 * This program demonstrate the use of auto-connect (connect to a service
 * without having to discover/specify an address) and how a program
 * can report discovery results to the user in case the service is not
 * unique on the network.
 * Of course, you need both auto-connect and query-ias in the kernel, and
 * a few bugs sorted out...
 *
 * Then, we show a cleaner way to perform discovery, by having better
 * memory allocation strategy, better handling of errors and setting the
 * hint mask in the kernel...
 *
 * Also, we include a nice feature which is a blocking discovery. Basically,
 * we ask the kernel to wake us up when it discover a device. This reduces
 * CPU usage (to zero) and decrease latency (to almost zero). This is
 * geared toward mobile devices (or to serve those mobile devices), but
 * also to implement "irmanager/irmonitor" kind of functionality...
 *
 * Also, everything about manipulating the IAS database and making query
 * is explained. That allow you to play with non-standard fields.
 *
 * Note that each feature require specific kernel support in the IrDA stack
 * so please check if your IrDA stack support that... In fact, this was
 * mostly written to test those kernel features.
 *
 * Jean Tourrilhes
 */

/* CONFIGURATION */
#define WAITFORDEVICE	1
#define CHECKBEFOREWAIT	1
#define SETHINTMASK	1
#define AUTOCONNECT	1
#define GETSOCKNAME	1
#define SETIAS		0
#define DELIAS		0

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <sys/stat.h>
#include <sys/wait.h>

#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>

#include <linux/types.h>
#include <linux/irda.h>

#ifndef AF_IRDA
#define AF_IRDA 23
#endif /* AF_IRDA */

/* Memory allocation for discovery */
#define DISC_MAX_DEVICES 10
#define DISC_BUF_LEN	sizeof(struct irda_device_list) + \
			sizeof(struct irda_device_info) * DISC_MAX_DEVICES

int frame_size = 1024;
int frame_number = 100;
unsigned char buf[8200];
int echo = 1;		/* Use echo service by default (0 = discard) */
int server = 0;		/* Act as a client by default (1 = server) */
int two = 0;		/* Open only one client sockets (1 = two) */

/*
 * Function irdaspray_sethintmask (fd)
 *
 *    Set the hint mask in the kernel to filter discoveries
 *
 * Note : Unless explicitely changed, this setting will remain valid
 * for any subsequent discoveries on this socket, such as :
 *	o Waiting for device -> getsockopt(IRLMP_WAITDEVICE)
 *	o Auto-connect -> connect(daddr = 0x0)
 *	o Standard discovery -> getsockopt(IRLMP_ENUMDEVICES)
 */
void irdaspray_sethintmask(int fd)
{
	unsigned char	hints[4];

	/*
	 * The hint mask we use is set to catch any device that potentially
	 * support things outside IrComm/IrLAN/IrLPT, so most device
	 * worth connecting to via IrTTP.
	 * Setting the hint mask with IrComm or IrObex could be usefull
	 * for some apps...
	 */
	hints[0] = HINT_COMPUTER | HINT_PDA;
	hints[1] = 0;

	/* Set the filter used for performing discovery */
	if (setsockopt(fd, SOL_IRLMP, IRLMP_HINT_MASK_SET,
		       hints, sizeof(hints))) 
	{
		perror("setsockopt");
		exit(-1);
	}
}

/*
 * Function irdaspray_check_discovery (fd)
 *
 *    Check the state of the discovery log
 *
 * See irdaspray_discover_devices() for details
 */
int irdaspray_check_discovery(int fd)
{
	struct irda_device_list *	list;
	unsigned char		buf[DISC_BUF_LEN];
	int len;

	/* Set the list to point to the correct place */
	list = (struct irda_device_list *) buf;
	len = DISC_BUF_LEN;

	/* Perform a discovery and get device list */
	if (getsockopt(fd, SOL_IRLMP, IRLMP_ENUMDEVICES, buf, &len)) {
		printf("Didn't find any devices!\n");
		return -1;
	}

	/* Did we got any ? (in some rare cases, this test is true) */
	if (list->len <= 0) {
		printf("Didn't find any devices!\n");
		return -1;
	}

	return 0;
}

/*
 * Function irdaspray_waitfor_devices (fd)
 *
 *    Wait until some device come into range...
 *
 * Note much to say. We set our hint mask, and call the stack with the
 * maximum amount of time we want to wait.
 * If a new device come in, we will wake up, otherwise it will timeout...
 * Note : this function is only triggered by *new* device, devices already
 * in range won't trigger this function.
 * The exact rules are :
 *	If a device has been discovered, or has change its hint bits,
 *	less than the discovery timeout in the past, then return,
 *	otherwise block until this happen or timeout.
 * Therefore, if you poll continuously this function, you'd better sleep
 * a bit after a positive result before calling it again...
 */
int irdaspray_waitfor_device(int fd)
{
	int timeout = 30000;	/* Block only for 30s */
	int len;

#if SETHINTMASK
	/* Set the filter used for performing discovery */
	irdaspray_sethintmask(fd);
#endif

#if CHECKBEFOREWAIT
	/* Note : before waiting for a new device to show up, we first
	 * check if a device has not already been discovered */
	if(irdaspray_check_discovery(fd) == 0)
		return 0;
#endif

	/* Wait for a device to be in range */
	printf("Waiting for a device...\n");
	len = sizeof(timeout);
	if (getsockopt(fd, SOL_IRLMP, IRLMP_WAITDEVICE, &timeout, &len)) {
		if(errno != EAGAIN) {
			perror("getsockopt-wait");
			exit(-1);
		}
		printf("Nothing found in the last %d s\n", timeout / 1000); 
		return -1;
	}

	return 0;	/* Found one device */
}

/*
 * Function echo_discover_devices (fd)
 *
 *    Try to discover some remote device(s) that we can connect to
 *
 * Note : in this function, the memory allocation for the discovery log
 * is done "the right way", so that we don't leak memory...
 */
int irdaspray_discover_devices(int fd, char *service_name)
{
	struct irda_device_list *	list;
	unsigned char		buf[DISC_BUF_LEN];
	struct irda_ias_set ias_query;
	int err;
	int len;
	int i;

	/* We are so proud of this feature that we show it again ! */
#if SETHINTMASK
	/* Set the filter used for performing discovery */
	irdaspray_sethintmask(fd);
#endif

	/* Set the list to point to the correct place */
	list = (struct irda_device_list *) buf;
	len = DISC_BUF_LEN;

	/* Perform a discovery and get device list */
	if (getsockopt(fd, SOL_IRLMP, IRLMP_ENUMDEVICES, buf, &len)) {
		printf("Didn't find any devices!\n");
		return -1;
	}

	/* Did we got any ? (in some rare cases, this test is true) */
	if (list->len <= 0) {
		printf("Didn't find any devices!\n");
		return -1;
	}

	/* List all devices */
	printf("Discovered %d devices :\n", list->len);
	for (i=0;i<list->len;i++) {
		printf("  [%d] name:  %s, daddr: 0x%08x",
		       i + 1, list->dev[i].info, list->dev[i].daddr);
		fflush(stdout);

		/* Ask if the requested service exist on this device */
		len = sizeof(ias_query);
		ias_query.daddr = list->dev[i].daddr;
		strcpy(ias_query.irda_class_name, service_name);
		strcpy(ias_query.irda_attrib_name, "IrDA:TinyTP:LsapSel");
		err = getsockopt(fd, SOL_IRLMP, IRLMP_IAS_QUERY,
				 &ias_query, &len);
		if(err == 0) {
			printf(", has service %s\n", service_name);
		} else {
			if(errno != EADDRNOTAVAIL)
				printf(" <can't query IAS>\n");
			else
				printf(", doesn't have %s\n", service_name);
		}
	}
			
	/* Ask the user */
	printf("Enter device number:");
	fflush(stdout);
	if(scanf("%X", &i) != 1)
		return -1;
	i--;
	if((i < 0) && (i > list->len))
		return -1;
	return(list->dev[i].daddr);
}

/*
 * IRIAS set/get/query tests
 */
void irias_play(int	fd)
{
	struct irda_ias_set ias_query;
	int len;

	/* Get the name of our own device */
	len = sizeof(ias_query);
	strcpy(ias_query.irda_class_name, "Device");
	strcpy(ias_query.irda_attrib_name, "DeviceName");
	if (!getsockopt(fd, SOL_IRLMP, IRLMP_IAS_GET, &ias_query, &len)) {
		printf("The name of our device is = ``%s''\n",
		       ias_query.attribute.irda_attrib_string.string);
	}

	/* Get the name of the remote device */
	len = sizeof(ias_query);
	strcpy(ias_query.irda_class_name, "Device");
	strcpy(ias_query.irda_attrib_name, "DeviceName");
	if (!getsockopt(fd, SOL_IRLMP, IRLMP_IAS_QUERY, &ias_query, &len)) {
		printf("The name of the other device is = ``%s''\n",
		       ias_query.attribute.irda_attrib_string.string);
	}

	/* Set an integer in IAS (new object) */
	strcpy(ias_query.irda_class_name, "my:object");
	ias_query.irda_attrib_type = IAS_INTEGER;
	strcpy(ias_query.irda_attrib_name, "my:int");
	ias_query.attribute.irda_attrib_int = 45;
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <my:object><my:int> in IAS\n");
	    perror("setsockopt");
	  }

	/* Set a string in IAS (existing object) */
	strcpy(ias_query.irda_class_name, "my:object");
	ias_query.irda_attrib_type = IAS_STRING;
	strcpy(ias_query.irda_attrib_name, "my:string");
	strcpy(ias_query.attribute.irda_attrib_string.string, "The String");
	ias_query.attribute.irda_attrib_string.len = strlen("The String");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <my:object><my:string> in IAS\n");
	    perror("setsockopt");
	  }

	/* Set another string in IAS (system object) */
	strcpy(ias_query.irda_class_name, "Device");
	ias_query.irda_attrib_type = IAS_STRING;
	strcpy(ias_query.irda_attrib_name, "Owner");
	strcpy(ias_query.attribute.irda_attrib_string.string, "Myself");
	ias_query.attribute.irda_attrib_string.len = strlen("Myself");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <Device><Owner> in IAS\n");
	    perror("setsockopt");
	  }

	/* Set yet another string in IAS (same object name as this socket) */
	if (echo)
		strcpy(ias_query.irda_class_name, "IrECHO");
	else
		strcpy(ias_query.irda_class_name, "IrDISCARD");
	ias_query.irda_attrib_type = IAS_STRING;
	strcpy(ias_query.irda_attrib_name, "App-Name");
	strcpy(ias_query.attribute.irda_attrib_string.string, "irdaspray.magic");
	ias_query.attribute.irda_attrib_string.len = strlen("irdaspray.magic");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <IrECHO><App-Name> in IAS\n");
	    perror("setsockopt");
	  }

	/* Set another integer in IAS (the object attached to this socket) */
	strcpy(ias_query.irda_class_name, "");
	ias_query.irda_attrib_type = IAS_INTEGER;
	strcpy(ias_query.irda_attrib_name, "App-Version");
	ias_query.attribute.irda_attrib_int = 3;
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <><App-Version> in IAS\n");
	    perror("setsockopt");
	  }

	/* Try to set a kernel attribute (should fail) */
	strcpy(ias_query.irda_class_name, "Device");
	strcpy(ias_query.irda_attrib_name, "DeviceName");
	strcpy(ias_query.attribute.irda_attrib_string.string, "Linux");
	ias_query.attribute.irda_attrib_string.len = strlen("Linux");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_SET, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't set <Device><DeviceName> in IAS\n");
	    perror("setsockopt");
	  }

	/* Read the integer in IAS */
	len = sizeof(ias_query);
	strcpy(ias_query.irda_class_name, "my:object");
	strcpy(ias_query.irda_attrib_name, "my:int");
	if (!getsockopt(fd, SOL_IRLMP, IRLMP_IAS_GET, &ias_query, 
		       &len)) 
	  {
	    printf("Type = %d\n", ias_query.irda_attrib_type);
	    printf("Int = %d\n", ias_query.attribute.irda_attrib_int);
	  }

	/* Read the string in IAS */
	len = sizeof(ias_query);
	strcpy(ias_query.irda_class_name, "my:object");
	strcpy(ias_query.irda_attrib_name, "my:string");
	if (!getsockopt(fd, SOL_IRLMP, IRLMP_IAS_GET, &ias_query, 
		       &len)) 
	  {
	    printf("Type = %d\n", ias_query.irda_attrib_type);
	    printf("String = ``%s''\n", ias_query.attribute.irda_attrib_string.string);
	  }
}

void irias_remove(int	fd)
{
	struct irda_ias_set ias_query;

	/* Delete the integer in IAS */
	strcpy(ias_query.irda_class_name, "my:object");
	strcpy(ias_query.irda_attrib_name, "my:int");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_DEL, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't remove <my:object><my:int> in IAS\n");
	    perror("setsockopt");
	  }

	/* Delete the string in IAS */
	strcpy(ias_query.irda_class_name, "my:object");
	strcpy(ias_query.irda_attrib_name, "my:string");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_DEL, &ias_query, 
		       sizeof(ias_query))) 
	  {
	    printf("Can't remove <my:object><my:string> in IAS\n");
	    perror("setsockopt");
	  }

	/* Delete the other string in IAS */
	strcpy(ias_query.irda_class_name, "Device");
	strcpy(ias_query.irda_attrib_name, "Owner");
	if (setsockopt(fd, SOL_IRLMP, IRLMP_IAS_DEL, &ias_query,