HG_REPOSITORIES/LPP/INSTRUMENTATION/lppserial Commit - r34:981d3945a0ec

Port enumeration Works on linux

jeandet@pc-de-jeandet3.LAB-LPP.LOCAL -

r34:981d3945a0ec alexis

parent child

Context file:

r34:981d3945a0ec

Collapse all files

install-sh created 755 +527 0

This diff has been collapsed as it changes many lines, (527 lines changed) Show them Hide them
	@@ -0,0 +1,527
		1	#!/bin/sh
		2	# install - install a program, script, or datafile
		3
		4	scriptversion=2011-01-19.21; # UTC
		5
		6	# This originates from X11R5 (mit/util/scripts/install.sh), which was
		7	# later released in X11R6 (xc/config/util/install.sh) with the
		8	# following copyright and license.
		9	#
		10	# Copyright (C) 1994 X Consortium
		11	#
		12	# Permission is hereby granted, free of charge, to any person obtaining a copy
		13	# of this software and associated documentation files (the "Software"), to
		14	# deal in the Software without restriction, including without limitation the
		15	# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
		16	# sell copies of the Software, and to permit persons to whom the Software is
		17	# furnished to do so, subject to the following conditions:
		18	#
		19	# The above copyright notice and this permission notice shall be included in
		20	# all copies or substantial portions of the Software.
		21	#
		22	# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
		23	# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
		24	# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
		25	# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
		26	# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
		27	# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
		28	#
		29	# Except as contained in this notice, the name of the X Consortium shall not
		30	# be used in advertising or otherwise to promote the sale, use or other deal-
		31	# ings in this Software without prior written authorization from the X Consor-
		32	# tium.
		33	#
		34	#
		35	# FSF changes to this file are in the public domain.
		36	#
		37	# Calling this script install-sh is preferred over install.sh, to prevent
		38	# `make' implicit rules from creating a file called install from it
		39	# when there is no Makefile.
		40	#
		41	# This script is compatible with the BSD install script, but was written
		42	# from scratch.
		43
		44	nl='
		45	'
		46	IFS=" "" $nl"
		47
		48	# set DOITPROG to echo to test this script
		49
		50	# Don't use :- since 4.3BSD and earlier shells don't like it.
		51	doit=${DOITPROG-}
		52	if test -z "$doit"; then
		53	doit_exec=exec
		54	else
		55	doit_exec=$doit
		56	fi
		57
		58	# Put in absolute file names if you don't have them in your path;
		59	# or use environment vars.
		60
		61	chgrpprog=${CHGRPPROG-chgrp}
		62	chmodprog=${CHMODPROG-chmod}
		63	chownprog=${CHOWNPROG-chown}
		64	cmpprog=${CMPPROG-cmp}
		65	cpprog=${CPPROG-cp}
		66	mkdirprog=${MKDIRPROG-mkdir}
		67	mvprog=${MVPROG-mv}
		68	rmprog=${RMPROG-rm}
		69	stripprog=${STRIPPROG-strip}
		70
		71	posix_glob='?'
		72	initialize_posix_glob='
		73	test "$posix_glob" != "?" \|\| {
		74	if (set -f) 2>/dev/null; then
		75	posix_glob=
		76	else
		77	posix_glob=:
		78	fi
		79	}
		80	'
		81
		82	posix_mkdir=
		83
		84	# Desired mode of installed file.
		85	mode=0755
		86
		87	chgrpcmd=
		88	chmodcmd=$chmodprog
		89	chowncmd=
		90	mvcmd=$mvprog
		91	rmcmd="$rmprog -f"
		92	stripcmd=
		93
		94	src=
		95	dst=
		96	dir_arg=
		97	dst_arg=
		98
		99	copy_on_change=false
		100	no_target_directory=
		101
		102	usage="\
		103	Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE
		104	or: $0 [OPTION]... SRCFILES... DIRECTORY
		105	or: $0 [OPTION]... -t DIRECTORY SRCFILES...
		106	or: $0 [OPTION]... -d DIRECTORIES...
		107
		108	In the 1st form, copy SRCFILE to DSTFILE.
		109	In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
		110	In the 4th, create DIRECTORIES.
		111
		112	Options:
		113	--help display this help and exit.
		114	--version display version info and exit.
		115
		116	-c (ignored)
		117	-C install only if different (preserve the last data modification time)
		118	-d create directories instead of installing files.
		119	-g GROUP $chgrpprog installed files to GROUP.
		120	-m MODE $chmodprog installed files to MODE.
		121	-o USER $chownprog installed files to USER.
		122	-s $stripprog installed files.
		123	-t DIRECTORY install into DIRECTORY.
		124	-T report an error if DSTFILE is a directory.
		125
		126	Environment variables override the default commands:
		127	CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
		128	RMPROG STRIPPROG
		129	"
		130
		131	while test $# -ne 0; do
		132	case $1 in
		133	-c) ;;
		134
		135	-C) copy_on_change=true;;
		136
		137	-d) dir_arg=true;;
		138
		139	-g) chgrpcmd="$chgrpprog $2"
		140	shift;;
		141
		142	--help) echo "$usage"; exit $?;;
		143
		144	-m) mode=$2
		145	case $mode in
		146	' ' \| ' ' \| *'
		147	'* \| ''* \| '?' \| '[')
		148	echo "$0: invalid mode: $mode" >&2
		149	exit 1;;
		150	esac
		151	shift;;
		152
		153	-o) chowncmd="$chownprog $2"
		154	shift;;
		155
		156	-s) stripcmd=$stripprog;;
		157
		158	-t) dst_arg=$2
		159	# Protect names problematic for `test' and other utilities.
		160	case $dst_arg in
		161	-* \| [=!]) dst_arg=./$dst_arg;;
		162	esac
		163	shift;;
		164
		165	-T) no_target_directory=true;;
		166
		167	--version) echo "$0 $scriptversion"; exit $?;;
		168
		169	--) shift
		170	break;;
		171
		172	-*) echo "$0: invalid option: $1" >&2
		173	exit 1;;
		174
		175	*) break;;
		176	esac
		177	shift
		178	done
		179
		180	if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
		181	# When -d is used, all remaining arguments are directories to create.
		182	# When -t is used, the destination is already specified.
		183	# Otherwise, the last argument is the destination. Remove it from $@.
		184	for arg
		185	do
		186	if test -n "$dst_arg"; then
		187	# $@ is not empty: it contains at least $arg.
		188	set fnord "$@" "$dst_arg"
		189	shift # fnord
		190	fi
		191	shift # arg
		192	dst_arg=$arg
		193	# Protect names problematic for `test' and other utilities.
		194	case $dst_arg in
		195	-* \| [=!]) dst_arg=./$dst_arg;;
		196	esac
		197	done
		198	fi
		199
		200	if test $# -eq 0; then
		201	if test -z "$dir_arg"; then
		202	echo "$0: no input file specified." >&2
		203	exit 1
		204	fi
		205	# It's OK to call `install-sh -d' without argument.
		206	# This can happen when creating conditional directories.
		207	exit 0
		208	fi
		209
		210	if test -z "$dir_arg"; then
		211	do_exit='(exit $ret); exit $ret'
		212	trap "ret=129; $do_exit" 1
		213	trap "ret=130; $do_exit" 2
		214	trap "ret=141; $do_exit" 13
		215	trap "ret=143; $do_exit" 15
		216
		217	# Set umask so as not to create temps with too-generous modes.
		218	# However, 'strip' requires both read and write access to temps.
		219	case $mode in
		220	# Optimize common cases.
		221	*644) cp_umask=133;;
		222	*755) cp_umask=22;;
		223
		224	*[0-7])
		225	if test -z "$stripcmd"; then
		226	u_plus_rw=
		227	else
		228	u_plus_rw='% 200'
		229	fi
		230	cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
		231	*)
		232	if test -z "$stripcmd"; then
		233	u_plus_rw=
		234	else
		235	u_plus_rw=,u+rw
		236	fi
		237	cp_umask=$mode$u_plus_rw;;
		238	esac
		239	fi
		240
		241	for src
		242	do
		243	# Protect names problematic for `test' and other utilities.
		244	case $src in
		245	-* \| [=!]) src=./$src;;
		246	esac
		247
		248	if test -n "$dir_arg"; then
		249	dst=$src
		250	dstdir=$dst
		251	test -d "$dstdir"
		252	dstdir_status=$?
		253	else
		254
		255	# Waiting for this to be detected by the "$cpprog $src $dsttmp" command
		256	# might cause directories to be created, which would be especially bad
		257	# if $src (and thus $dsttmp) contains '*'.
		258	if test ! -f "$src" && test ! -d "$src"; then
		259	echo "$0: $src does not exist." >&2
		260	exit 1
		261	fi
		262
		263	if test -z "$dst_arg"; then
		264	echo "$0: no destination specified." >&2
		265	exit 1
		266	fi
		267	dst=$dst_arg
		268
		269	# If destination is a directory, append the input filename; won't work
		270	# if double slashes aren't ignored.
		271	if test -d "$dst"; then
		272	if test -n "$no_target_directory"; then
		273	echo "$0: $dst_arg: Is a directory" >&2
		274	exit 1
		275	fi
		276	dstdir=$dst
		277	dst=$dstdir/`basename "$src"`
		278	dstdir_status=0
		279	else
		280	# Prefer dirname, but fall back on a substitute if dirname fails.
		281	dstdir=`
		282	(dirname "$dst") 2>/dev/null \|\|
		283	expr X"$dst" : 'X$.[^/]$//[^/][^/]/$' \\| \
		284	X"$dst" : 'X$//$[^/]' \\| \
		285	X"$dst" : 'X$//$$' \\| \
		286	X"$dst" : 'X$/$' \\| . 2>/dev/null \|\|
		287	echo X"$dst" \|
		288	sed '/^X$.[^/]$\/\/[^/][^/]\/$/{
		289	s//\1/
		290	q
		291	}
		292	/^X$\/\/$[^/].*/{
		293	s//\1/
		294	q
		295	}
		296	/^X$\/\/$$/{
		297	s//\1/
		298	q
		299	}
		300	/^X$\/$.*/{
		301	s//\1/
		302	q
		303	}
		304	s/.*/./; q'
		305	`
		306
		307	test -d "$dstdir"
		308	dstdir_status=$?
		309	fi
		310	fi
		311
		312	obsolete_mkdir_used=false
		313
		314	if test $dstdir_status != 0; then
		315	case $posix_mkdir in
		316	'')
		317	# Create intermediate dirs using mode 755 as modified by the umask.
		318	# This is like FreeBSD 'install' as of 1997-10-28.
		319	umask=`umask`
		320	case $stripcmd.$umask in
		321	# Optimize common cases.
		322	*[2367][2367]) mkdir_umask=$umask;;
		323	.*0[02][02] \| .[02][02] \| .[02]) mkdir_umask=22;;
		324
		325	*[0-7])
		326	mkdir_umask=`expr $umask + 22 \
		327	- $umask % 100 % 40 + $umask % 20 \
		328	- $umask % 10 % 4 + $umask % 2
		329	`;;
		330	*) mkdir_umask=$umask,go-w;;
		331	esac
		332
		333	# With -d, create the new directory with the user-specified mode.
		334	# Otherwise, rely on $mkdir_umask.
		335	if test -n "$dir_arg"; then
		336	mkdir_mode=-m$mode
		337	else
		338	mkdir_mode=
		339	fi
		340
		341	posix_mkdir=false
		342	case $umask in
		343	*[123567][0-7][0-7])
		344	# POSIX mkdir -p sets u+wx bits regardless of umask, which
		345	# is incompatible with FreeBSD 'install' when (umask & 300) != 0.
		346	;;
		347	*)
		348	tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
		349	trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
		350
		351	if (umask $mkdir_umask &&
		352	exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
		353	then
		354	if test -z "$dir_arg" \|\| {
		355	# Check for POSIX incompatibilities with -m.
		356	# HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
		357	# other-writeable bit of parent directory when it shouldn't.
		358	# FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
		359	ls_ld_tmpdir=`ls -ld "$tmpdir"`
		360	case $ls_ld_tmpdir in
		361	d????-?r-*) different_mode=700;;
		362	d????-?--*) different_mode=755;;
		363	*) false;;
		364	esac &&
		365	$mkdirprog -m$different_mode -p -- "$tmpdir" && {
		366	ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
		367	test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
		368	}
		369	}
		370	then posix_mkdir=:
		371	fi
		372	rmdir "$tmpdir/d" "$tmpdir"
		373	else
		374	# Remove any dirs left behind by ancient mkdir implementations.
		375	rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
		376	fi
		377	trap '' 0;;
		378	esac;;
		379	esac
		380
		381	if
		382	$posix_mkdir && (
		383	umask $mkdir_umask &&
		384	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
		385	)
		386	then :
		387	else
		388
		389	# The umask is ridiculous, or mkdir does not conform to POSIX,
		390	# or it failed possibly due to a race condition. Create the
		391	# directory the slow way, step by step, checking for races as we go.
		392
		393	case $dstdir in
		394	/*) prefix='/';;
		395	[-=!]*) prefix='./';;
		396	*) prefix='';;
		397	esac
		398
		399	eval "$initialize_posix_glob"
		400
		401	oIFS=$IFS
		402	IFS=/
		403	$posix_glob set -f
		404	set fnord $dstdir
		405	shift
		406	$posix_glob set +f
		407	IFS=$oIFS
		408
		409	prefixes=
		410
		411	for d
		412	do
		413	test X"$d" = X && continue
		414
		415	prefix=$prefix$d
		416	if test -d "$prefix"; then
		417	prefixes=
		418	else
		419	if $posix_mkdir; then
		420	(umask=$mkdir_umask &&
		421	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
		422	# Don't fail if two instances are running concurrently.
		423	test -d "$prefix" \|\| exit 1
		424	else
		425	case $prefix in
		426	\') qprefix=`echo "$prefix" \| sed "s/'/'\\\\\\\\''/g"`;;
		427	*) qprefix=$prefix;;
		428	esac
		429	prefixes="$prefixes '$qprefix'"
		430	fi
		431	fi
		432	prefix=$prefix/
		433	done
		434
		435	if test -n "$prefixes"; then
		436	# Don't fail if two instances are running concurrently.
		437	(umask $mkdir_umask &&
		438	eval "\$doit_exec \$mkdirprog $prefixes") \|\|
		439	test -d "$dstdir" \|\| exit 1
		440	obsolete_mkdir_used=true
		441	fi
		442	fi
		443	fi
		444
		445	if test -n "$dir_arg"; then
		446	{ test -z "$chowncmd" \|\| $doit $chowncmd "$dst"; } &&
		447	{ test -z "$chgrpcmd" \|\| $doit $chgrpcmd "$dst"; } &&
		448	{ test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false \|\|
		449	test -z "$chmodcmd" \|\| $doit $chmodcmd $mode "$dst"; } \|\| exit 1
		450	else
		451
		452	# Make a couple of temp file names in the proper directory.
		453	dsttmp=$dstdir/_inst.$$_
		454	rmtmp=$dstdir/_rm.$$_
		455
		456	# Trap to clean up those temp files at exit.
		457	trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
		458
		459	# Copy the file name to the temp name.
		460	(umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
		461
		462	# and set any options; do chmod last to preserve setuid bits.
		463	#
		464	# If any of these fail, we abort the whole thing. If we want to
		465	# ignore errors from any of these, just make sure not to ignore
		466	# errors from the above "$doit $cpprog $src $dsttmp" command.
		467	#
		468	{ test -z "$chowncmd" \|\| $doit $chowncmd "$dsttmp"; } &&
		469	{ test -z "$chgrpcmd" \|\| $doit $chgrpcmd "$dsttmp"; } &&
		470	{ test -z "$stripcmd" \|\| $doit $stripcmd "$dsttmp"; } &&
		471	{ test -z "$chmodcmd" \|\| $doit $chmodcmd $mode "$dsttmp"; } &&
		472
		473	# If -C, don't bother to copy if it wouldn't change the file.
		474	if $copy_on_change &&
		475	old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` &&
		476	new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` &&
		477
		478	eval "$initialize_posix_glob" &&
		479	$posix_glob set -f &&
		480	set X $old && old=:$2:$4:$5:$6 &&
		481	set X $new && new=:$2:$4:$5:$6 &&
		482	$posix_glob set +f &&
		483
		484	test "$old" = "$new" &&
		485	$cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
		486	then
		487	rm -f "$dsttmp"
		488	else
		489	# Rename the file to the real destination.
		490	$doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null \|\|
		491
		492	# The rename failed, perhaps because mv can't rename something else
		493	# to itself, or perhaps because mv is so ancient that it does not
		494	# support -f.
		495	{
		496	# Now remove or move aside any old file at destination location.
		497	# We try this two ways since rm can't unlink itself on some
		498	# systems and the destination file might be busy for other
		499	# reasons. In this case, the final cleanup might fail but the new
		500	# file should still install successfully.
		501	{
		502	test ! -f "$dst" \|\|
		503	$doit $rmcmd -f "$dst" 2>/dev/null \|\|
		504	{ $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
		505	{ $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
		506	} \|\|
		507	{ echo "$0: cannot unlink or rename $dst" >&2
		508	(exit 1); exit 1
		509	}
		510	} &&
		511
		512	# Now rename the file to the real destination.
		513	$doit $mvcmd "$dsttmp" "$dst"
		514	}
		515	fi \|\| exit 1
		516
		517	trap '' 0
		518	fi
		519	done
		520
		521	# Local variables:
		522	# eval: (add-hook 'write-file-hooks 'time-stamp)
		523	# time-stamp-start: "scriptversion="
		524	# time-stamp-format: "%:y-%02m-%02d.%02H"
		525	# time-stamp-time-zone: "UTC"
		526	# time-stamp-end: "; # UTC"
		527	# End:

configure.ac +6 -1

             #                                               -*- Autoconf -*-
             # Process this file with autoconf to produce a configure script.
             AC_PREREQ([2.67])
             AC_INIT([librs232],[2.1.0],[alexis.jeandet@lpp.polytechnique.fr],[rs232],[http://www.lpp.fr])
             AM_INIT_AUTOMAKE([1.10 -Wall foreign])
             AC_CONFIG_MACRO_DIR([m4])
             # Checks for programs.
             AC_CONFIG_HEADERS([src/rs232config.h])
             AC_PROG_CC
             AM_PROG_CC_STDC
+            AC_PROG_INSTALL
             AC_C_CONST
             AC_LIBTOOL_WIN32_DLL
             AM_PROG_LIBTOOL
+            AC_PROG_LN_S
+            AC_PROG_MAKE_SET
+            AC_PROG_RANLIB
             #LT_INIT
             #AC_PROG_MAKE_SET
             # Checks for libraries.
             # Checks for header files.
-            AC_CHECK_HEADERS([stdio.h string.h fcntl.h errno.h unistd.h termios.h termio.h windows.h])
+            AC_CHECK_HEADERS([stdio.h string.h fcntl.h errno.h unistd.h termios.h termio.h dirent.h windows.h])
             AC_SUBST([RS232_SO_VERSION], [2:1:0])
             AC_SUBST([RS232_API_VERSION], [2.1])
             # Checks for typedefs, structures, and compiler characteristics.
             # Checks for library functions.
             AC_CONFIG_FILES([Makefile src/Makefile rs232-${RS232_API_VERSION}.pc:rs232.pc.in])
             AC_OUTPUT

rs232.pc.in +1 -1

             prefix=@prefix@
             exec_prefix=@exec_prefix@
             libdir=@libdir@
             includedir=@includedir@
             Name: @PACKAGE_NAME@
-            Description: Example C++ library.
+            Description: Standard RS232 library.
             Version: @PACKAGE_VERSION@
             URL: @PACKAGE_URL@
             Libs: -L${libdir} -lrs232-@RS232_API_VERSION@
             Cflags: -I${includedir}/rs232-@RS232_API_VERSION@ -I${libdir}/rs232-@RS232_API_VERSION@/include

src/RS232_unix.c +62 -1

             #include <stdio.h>
             #include <unistd.h>
             #include <fcntl.h>
             #include <string.h>
             #include <errno.h>
             #include <malloc.h>
+            #include <dirent.h>
+            #include <limits.h>
+            #include <stdlib.h>
+            #include <sys/stat.h>
             #include "rs232config.h"
             #ifdef HAVE_TERMIOS_H
                    #include <termios.h>
             #endif
             #ifdef HAVE_TERMIO_H
                    #include <termio.h>
             #endif
             #include "RS232.h"
             #ifdef HAVE_WINDOWS_H
             #else
             #ifdef HAVE_TERMIOS_H
             rs232speed_t rs232cfspeed(unsigned int BaudeRate);
             rs232port_t rs232open(char* psPortName)
             {
                     rs232port_t fd;
             	fd = (rs232port_t)open(psPortName, O_RDWR | O_NOCTTY | O_NDELAY);
             	fcntl((int)fd, F_SETFL, 0);
             	//fd = open(psPortName, O_RDWR | O_NOCTTY);
             	#ifdef debug
             		if(fd==-1)printf("can't open Port\n");
             	#endif
             	return fd;
             }
             int rs232close(rs232port_t fd)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		close(fd);
             		return 0;
             	}
             }
             rs232portslist_t* rs232getportlist()
             {
+            	struct dirent *dp;
+            	char* path="/dev/serial/by-id";
+            	DIR *dir = opendir(path);
+            	rs232portslist_t* firstitem=NULL;
+            	rs232portslist_t* previtem=NULL;
+            	char linkname[1024];
+            	int i=0;
+            	if(dir!=NULL)
+            	{
+            		while ((dp=readdir(dir)) != NULL)
+            		{
+            			char* name = (char*)malloc(1024);
+            			for(i=0;i<1024;i++)
+            			{
+            				name[i]='\0';
+            				linkname[i]='\0';
+            			}
+            			struct stat statbuf;
+            			strcpy(linkname,path);
+            			strcat(linkname,"/");
+            			strcat(linkname,dp->d_name);
+            			lstat(linkname, &statbuf);
+            			if(S_ISLNK(statbuf.st_mode))
+            			{
+            				if(-1!=readlink(linkname,name,1024))
+            				{
+            					for(i=0;i<1024;i++)
+            					{
+            						linkname[i]='\0';
+            					}
+            					strcpy(linkname,path);
+            					strcat(linkname,"/");
+            					strcat(linkname,name);
+            					for(i=0;i<1024;i++)
+            					{
+            						name[i]='\0';
+            					}
+            					if(NULL!=realpath(linkname, name))
+            					{
+            						rs232portslist_t* item = (rs232portslist_t*)malloc(sizeof(rs232portslist_t));
+            						item->name = name;
+            						item->next = NULL;
+            						if(NULL!=previtem)previtem->next = item;
+            						previtem = item;
+            						if(NULL==firstitem)firstitem = item;
+            					}
+            				}
+            			}
             		}
+            	}
+            	return firstitem;
+            }
             void rs232deleteportlist(rs232portslist_t* list)
             {
+            	if(list!=NULL)
+            	{
+            		if(list->next != NULL)
+            			rs232deleteportlist(list->next);
+            		free(list);
+            	}
             }
             int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
             {
               if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		struct termios terminos;
             		tcgetattr(fd, &terminos);
             		cfsetispeed(&terminos, rs232cfspeed(BaudeRate));
             		cfsetospeed(&terminos, rs232cfspeed(BaudeRate));
             		terminos.c_cflag |= (CLOCAL | CREAD);
             		rs232cfparity((int)fd, &terminos, Parity);
             		rs232cfnbstop((int)fd, &terminos, NbStop);
             		rs232cfcsize((int)fd, &terminos, ChSize);
             		terminos.c_cc[VMIN]=0;
                     	terminos.c_cc[VTIME]=1;
                     	tcflush(fd, TCIFLUSH);
             		#ifdef debug
             			if(tcsetattr(fd, TCSANOW, &terminos)!=0)printf("bad setup\n");
             		#else
             			tcsetattr(fd, TCSANOW, &terminos);
             		#endif
             		return 0;
             	}
             }
             int rs232setbaudrate(rs232port_t fd, int baudrate)
             {
               	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
                             cfsetispeed(&terminos, rs232cfspeed(baudrate));
             		cfsetospeed(&terminos, rs232cfspeed(baudrate));
                             tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setparity(rs232port_t fd, rs232parity Parity)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		terminos.c_cflag &= ~PARENB;
             		terminos.c_cflag &= ~PARODD;
             		switch(Parity)
             		{
             			case rs232parityNo:
             				terminos.c_cflag &= ~PARENB;
             				break;
             			case rs232parityOdd:
             				terminos.c_cflag |= PARENB;
             				terminos.c_cflag |= PARODD;
             				break;
             			case rs232parityEven:
             				terminos.c_cflag |= PARENB;
             				terminos.c_cflag &= ~PARODD;
             				break;
             			default:
             				terminos.c_cflag &= ~PARENB;
             				break;
             		}
                             tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		switch(NbStop)
             		{
             			case rs232OneStop:
             			     terminos.c_cflag &= ~CSTOPB;
             			     break;
                                     case rs232One5Stop:
             				terminos.c_cflag |= CSTOPB;
                                             break;
             			case rs232TwoStop:
             				terminos.c_cflag |= CSTOPB;
                                             break;
             			default:
             				terminos.c_cflag &= ~CSTOPB;
                                             break;
             		}
             		tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             int rs232setcsize(rs232port_t fd, int ChSize)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
                             struct termios terminos;
             		tcgetattr((int)fd, &terminos);
             		terminos.c_cflag &= ~CSIZE;
             		switch(ChSize)
             		{
             			case 5:
             				terminos.c_cflag |= CS5;
             			break;
             			case 6:
             				terminos.c_cflag |= CS6;
             			break;
             			case 7:
             				terminos.c_cflag |= CS7;
             			break;
             			default:
             				terminos.c_cflag |= CS8;
             			break;
             		}
             		tcsetattr((int)fd, TCSANOW, &terminos);
             		return 0;
             	}
             }
             rs232speed_t rs232cfspeed(unsigned int BaudeRate)
             {
             	if(BaudeRate<25)
             		return B0;
             	if(BaudeRate<67)
             		return B50;
             	if(BaudeRate<93)
             		return B75;
             	if(BaudeRate<123)
             		return B110;
             	if(BaudeRate<142)
             		return B134;
             	if(BaudeRate<175)
             		return B150;
             	if(BaudeRate<250)
             		return B200;
             	if(BaudeRate<450)
             		return B300;
             	if(BaudeRate<900)
             		return B600;
             	if(BaudeRate<1500)
             		return B1200;
             	if(BaudeRate<2100)
             		return B1800;
             	if(BaudeRate<3600)
             		return B2400;
             	if(BaudeRate<7200)
             		return B4800;
             	if(BaudeRate<1400)
             		return B9600;
             	if(BaudeRate<28800)
             		return B19200;
             	if(BaudeRate<48000)
             		return B38400;
             	if(BaudeRate<86400)
             		return B57600;
             	if(BaudeRate<172800)
             		return B115200;
             	else
             		return B230400;
             }
             int rs232cfparity(int fd, struct termios *terminos, rs232parity Parity)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		terminos->c_cflag &= ~PARENB;
             		terminos->c_cflag &= ~PARODD;
                             switch(Parity)
             		{
             			case rs232parityNo:
             				terminos->c_cflag &= ~PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             			case rs232parityOdd:
             				terminos->c_cflag |= PARENB;
             				terminos->c_cflag |= PARODD;
             				break;
             			case rs232parityEven:
             				terminos->c_cflag |= PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             			default:
             				terminos->c_cflag &= ~PARENB;
             				terminos->c_cflag &= ~PARODD;
             				break;
             		}
             		return 0;
             	}
             }
             int rs232cfnbstop(int fd, struct termios *terminos, rs232stop NbStop)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		switch(NbStop)
             		{
             			case 2:
             				terminos->c_cflag |= CSTOPB;
             			break;
             			default:
             				terminos->c_cflag &= ~CSTOPB;
             			break;
             		}
             		return 0;
             	}
             }
             int rs232cfcsize(int fd, struct termios *terminos, int ChSize)
             {
             	if ((int)fd == -1)
             	{
             		return fd;
             	}
             	else
             	{
             		terminos->c_cflag &= ~CSIZE;
             		switch(ChSize)
             		{
             			case 5:
             				terminos->c_cflag |= CS5;
             			break;
             			case 6:
             				terminos->c_cflag |= CS6;
             			break;
             			case 7:
             				terminos->c_cflag |= CS7;
             			break;
             			default:
             				terminos->c_cflag |= CS8;
             			break;
             		}
             		return 0;
             	}
             }
             int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		return write((int)fd, psWrite, WriteBufferSize);
             	}
             }
             int rs232read(rs232port_t fd,char *psReadHex, int ReadBufferSize)
             {
             	if ((int)fd == -1)
             	{
             		return -1;
             	}
             	else
             	{
             		return read((int)fd, psReadHex, ReadBufferSize);
             	}
             }
             int rs232setRTS(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status &= ~TIOCM_RTS;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232clearRTS(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status |= TIOCM_RTS;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232setDTR(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status &= ~TIOCM_DTR;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232clearDTR(rs232port_t fd)
             {
              int status;
              ioctl((int)fd, TIOCMGET, &status);
              status |= TIOCM_DTR;
              if (ioctl((int)fd, TIOCMSET, &status))
              {
                return -1;
              }
              return 0;
             }
             int rs232saferead(rs232port_t fd,char* data,int count )
             {
             	int read=0;
             	int i=0;
             	for(i=0;i<100;i++)
             	{
             		read = rs232read((int)fd,data,count);
             		count -=read;
             		data+=read;
             		if(count==0)
             			return 0;
             	}
             	return -1;
             }
             int rs232safewrite(rs232port_t fd,char* data,int count)
             {
             	int written=0;
             	int i=0;
             	for(i=0;i<1000;i++)
             	{
             		written = rs232write((int)fd,data+written,count);
             		count-=written;
             		data+=written;
             		if(count==0)
             			return 0;
             	}
             	return -1;
             }
             #endif
             #endif //#ifdef HAVE_TERMIOS_H

src/RS232_win.c +33 -3

             #include "rs232config.h"
             #include <stdio.h>
             #include <unistd.h>
             #include <fcntl.h>
             #include <string.h>
             #include <errno.h>
             #include <malloc.h>
             #ifdef HAVE_WINDOWS_H
                    #include <windows.h>
             #endif
             #include "RS232.h"
             #ifdef HAVE_WINDOWS_H
             int privatedecodeparity(rs232parity Parity )
             {
             	switch(Parity)
             	{
             		case rs232parityNo:
             			return NOPARITY;
             			break;
             		case rs232parityOdd:
             			return ODDPARITY;
             			break;
             		case rs232parityEven:
             			return EVENPARITY;
             			break;
             		default:
             			return NOPARITY;
             			break;
             	}
             }
             int privatedecodestop(rs232stop NbStop)
             {
             	switch(NbStop)
             	{
             		case rs232OneStop:
             			return ONESTOPBIT;
             			break;
             		case rs232One5Stop:
             			return ONE5STOPBITS;
             			break;
             		case rs232TwoStop:
             			return TWOSTOPBITS;
             			break;
             		default:
             			return ONESTOPBIT;
             			break;
             	}
             }
             rs232speed_t rs232cfspeed(unsigned int BaudeRate)
             {
             	if(BaudeRate<123)
             		return (rs232speed_t)CBR_110;
             	if(BaudeRate<450)
             		return (rs232speed_t)CBR_300;
             	if(BaudeRate<900)
             		return (rs232speed_t)CBR_600;
             	if(BaudeRate<1500)
             		return (rs232speed_t)CBR_1200;
             	if(BaudeRate<3600)
             		return (rs232speed_t)CBR_2400;
             	if(BaudeRate<7200)
             		return (rs232speed_t)CBR_4800;
             	if(BaudeRate<14000)
             		return (rs232speed_t)CBR_9600;
             	if(BaudeRate<16800)
             		return (rs232speed_t)CBR_14400;
             	if(BaudeRate<28800)
             		return (rs232speed_t)CBR_19200;
             	if(BaudeRate<48000)
             		return (rs232speed_t)CBR_38400;
             	if(BaudeRate<86400)
             		return (rs232speed_t)CBR_57600;
             	if(BaudeRate<172800)
             		return (rs232speed_t)CBR_115200;
             	else
             		return (rs232speed_t)CBR_256000;
             }
             rs232port_t rs232open(char* psPortName)
             {
                     rs232port_t fd;
                     fd = (rs232port_t)CreateFile(psPortName,GENERIC_READ | GENERIC_WRITE,0,0,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,0);
                     #ifdef debug
             		if(fd==(rs232port_t)INVALID_HANDLE_VALUE)
             		{
             			printf("can't open Port\n");
             			return (rs232port_t)badPortValue;
             		}
             	#endif
             	return fd;
             }
             int rs232close(rs232port_t fd)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             CloseHandle((HANDLE)fd);
             		return rs232noerr;
             	}
             }
-            rs232portslist_t* rs232getportlist()
+            rs232portslist_t* rs232getportlist()  //here is the very dirty way!
+            {
+            	int i=0;
+            	char* devName="COM111";
+            	rs232port_t testport;
+            	rs232portslist_t* firstitem=NULL;
+            	rs232portslist_t* previtem=NULL;
+            	for(i=0;i<256;i++)
             	{
+            		devName[3] = '\0';
+            		devName[4] = '\0';
+            		devName[5] = '\0';
+            		devName[6] = '\0';
+            		sprintf(devName+3,"%d",i);
+            		testport= rs232open(devName);
+            		if(testport != (rs232port_t)badPortValue)
+            		{
+            			rs232portslist_t* item = (rs232portslist_t*)malloc(sizeof(rs232portslist_t));
+            			char* name = (char*)malloc(7);
+            			strcpy(name,devName);
+            			item->name = name;
+            			item->next = NULL;
+            			if(NULL!=previtem)previtem->next = item;
+            			previtem = item;
+            			if(NULL==firstitem)firstitem = item;
+            		}
+            	}
+            	return firstitem;
             }
             void rs232deleteportlist(rs232portslist_t* list)
             {
+            	if(list!=NULL)
+            	{
+            		if(list->next != NULL)
+            			rs232deleteportlist(list->next);
+            		free(list);
+            	}
             }
             int rs232setup(rs232port_t fd, int ChSize, int BaudeRate, rs232parity Parity, rs232stop NbStop)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.BaudRate=rs232cfspeed(BaudeRate);
                             dcbSerialParams.ByteSize=ChSize;
                             dcbSerialParams.StopBits=privatedecodestop(NbStop);
                             dcbSerialParams.Parity=privatedecodeparity(Parity);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
                             COMMTIMEOUTS timeouts={0};
                             timeouts.ReadIntervalTimeout=100;
                             timeouts.ReadTotalTimeoutConstant=100;
                             timeouts.ReadTotalTimeoutMultiplier=1;
                             timeouts.WriteTotalTimeoutConstant=100;
                             timeouts.WriteTotalTimeoutMultiplier=10;
                             SetCommTimeouts((HANDLE)fd, &timeouts);
             		return rs232noerr;
             	}
             }
             int rs232setbaudrate(rs232port_t fd, int baudrate)
             {
               	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.BaudRate=rs232cfspeed(baudrate);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setparity(rs232port_t fd, rs232parity Parity)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.Parity = privatedecodeparity(Parity);
                             SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setnbstop(rs232port_t fd, rs232stop NbStop)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
                             dcbSerialParams.StopBits = privatedecodestop(NbStop);
             		SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232setcsize(rs232port_t fd, int ChSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DCB dcbSerialParams = {0};
                             dcbSerialParams.DCBlength=sizeof(dcbSerialParams);
                             GetCommState((HANDLE)fd, &dcbSerialParams);
             		dcbSerialParams.ByteSize = ChSize;
             		SetCommState((HANDLE)fd, &dcbSerialParams);
             		return rs232noerr;
             	}
             }
             int rs232write(rs232port_t fd,char *psWrite, int WriteBufferSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
             		DWORD dwBytesWriten = 0;
                             WriteFile((HANDLE)fd, psWrite, WriteBufferSize, &dwBytesWriten, NULL);
                             return  dwBytesWriten;
             	}
             }
             int rs232read(rs232port_t fd,char *psRead, int ReadBufferSize)
             {
             	if (fd == (rs232port_t)INVALID_HANDLE_VALUE)
             	{
             		return (rs232port_t)badPortValue;
             	}
             	else
             	{
                             DWORD dwBytesRead = 0;
                             ReadFile((HANDLE)fd, psRead, ReadBufferSize, &dwBytesRead, NULL);
                             return  dwBytesRead;
             	}
             }
             int rs232saferead(rs232port_t fd,char* data,int count )
             {
             	int read=0;
             	int i=0;
             	for(i=0;i<100;i++)
             	{
             		read = rs232read(fd,data,count);
             		count -=read;
             		data+=read;
             		if(count==0)
             			return rs232noerr;
             	}
             	return -1;
             }
             int rs232safewrite(rs232port_t fd,char* data,int count)
             {
             	int written=0;
             	int i=0;
             	for(i=0;i<1000;i++)
             	{
             		written = rs232write(fd,data+written,count);
             		count-=written;
             		data+=written;
             		if(count==0)
             			return rs232noerr;
             	}
             	return -1;
             }
             int rs232setRTS(rs232port_t fd)
             {
               if(EscapeCommFunction((HANDLE)fd, CLRRTS))
               	return rs232noerr;
               return -1;
             }
             int rs232clearRTS(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, SETRTS))
               	return rs232noerr;
               return -1;
             }
             int rs232setDTR(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, CLRDTR))
               	return rs232noerr;
               return -1;
             }
             int rs232clearDTR(rs232port_t fd)
             {
              if(EscapeCommFunction((HANDLE)fd, SETDTR))
               	return rs232noerr;
               return -1;
             }
             #endif //#ifdef HAVE_WINDOWS_H

src/rs232config.h.in +3 0

             /* src/rs232config.h.in.  Generated from configure.ac by autoheader.  */
+            /* Define to 1 if you have the <dirent.h> header file. */
+            #undef HAVE_DIRENT_H
             /* Define to 1 if you have the <dlfcn.h> header file. */
             #undef HAVE_DLFCN_H
             /* Define to 1 if you have the <errno.h> header file. */
             #undef HAVE_ERRNO_H
             /* Define to 1 if you have the <fcntl.h> header file. */
             #undef HAVE_FCNTL_H
             /* Define to 1 if you have the <inttypes.h> header file. */
             #undef HAVE_INTTYPES_H
             /* Define to 1 if you have the <memory.h> header file. */
             #undef HAVE_MEMORY_H
             /* Define to 1 if you have the <stdint.h> header file. */
             #undef HAVE_STDINT_H
             /* Define to 1 if you have the <stdio.h> header file. */
             #undef HAVE_STDIO_H
             /* Define to 1 if you have the <stdlib.h> header file. */
             #undef HAVE_STDLIB_H
             /* Define to 1 if you have the <strings.h> header file. */
             #undef HAVE_STRINGS_H
             /* Define to 1 if you have the <string.h> header file. */
             #undef HAVE_STRING_H
             /* Define to 1 if you have the <sys/stat.h> header file. */
             #undef HAVE_SYS_STAT_H
             /* Define to 1 if you have the <sys/types.h> header file. */
             #undef HAVE_SYS_TYPES_H
             /* Define to 1 if you have the <termios.h> header file. */
             #undef HAVE_TERMIOS_H
             /* Define to 1 if you have the <termio.h> header file. */
             #undef HAVE_TERMIO_H
             /* Define to 1 if you have the <unistd.h> header file. */
             #undef HAVE_UNISTD_H
             /* Define to 1 if you have the <windows.h> header file. */
             #undef HAVE_WINDOWS_H
             /* Define to the sub-directory in which libtool stores uninstalled libraries.
                */
             #undef LT_OBJDIR
             /* Name of package */
             #undef PACKAGE
             /* Define to the address where bug reports for this package should be sent. */
             #undef PACKAGE_BUGREPORT
             /* Define to the full name of this package. */
             #undef PACKAGE_NAME
             /* Define to the full name and version of this package. */
             #undef PACKAGE_STRING
             /* Define to the one symbol short name of this package. */
             #undef PACKAGE_TARNAME
             /* Define to the home page for this package. */
             #undef PACKAGE_URL
             /* Define to the version of this package. */
             #undef PACKAGE_VERSION
             /* Define to 1 if you have the ANSI C header files. */
             #undef STDC_HEADERS
             /* Version number of package */
             #undef VERSION
             /* Define to empty if `const' does not conform to ANSI C. */
             #undef const

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages