obex-data-server-0.4.6/ 0000755 0001750 0001750 00000000000 11546317666 011711 5 0000000 0000000 obex-data-server-0.4.6/depcomp 0000755 0001750 0001750 00000044267 11331674343 013211 0000000 0000000 #! /bin/sh
# depcomp - compile a program generating dependencies as side-effects
scriptversion=2009-04-28.21; # UTC
# Copyright (C) 1999, 2000, 2003, 2004, 2005, 2006, 2007, 2009 Free
# Software Foundation, Inc.
# 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, 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, see .
# As a special exception to the GNU General Public License, if you
# distribute this file as part of a program that contains a
# configuration script generated by Autoconf, you may include it under
# the same distribution terms that you use for the rest of that program.
# Originally written by Alexandre Oliva .
case $1 in
'')
echo "$0: No command. Try \`$0 --help' for more information." 1>&2
exit 1;
;;
-h | --h*)
cat <<\EOF
Usage: depcomp [--help] [--version] PROGRAM [ARGS]
Run PROGRAMS ARGS to compile a file, generating dependencies
as side-effects.
Environment variables:
depmode Dependency tracking mode.
source Source file read by `PROGRAMS ARGS'.
object Object file output by `PROGRAMS ARGS'.
DEPDIR directory where to store dependencies.
depfile Dependency file to output.
tmpdepfile Temporary file to use when outputing dependencies.
libtool Whether libtool is used (yes/no).
Report bugs to .
EOF
exit $?
;;
-v | --v*)
echo "depcomp $scriptversion"
exit $?
;;
esac
if test -z "$depmode" || test -z "$source" || test -z "$object"; then
echo "depcomp: Variables source, object and depmode must be set" 1>&2
exit 1
fi
# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
depfile=${depfile-`echo "$object" |
sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`}
tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`}
rm -f "$tmpdepfile"
# Some modes work just like other modes, but use different flags. We
# parameterize here, but still list the modes in the big case below,
# to make depend.m4 easier to write. Note that we *cannot* use a case
# here, because this file can only contain one case statement.
if test "$depmode" = hp; then
# HP compiler uses -M and no extra arg.
gccflag=-M
depmode=gcc
fi
if test "$depmode" = dashXmstdout; then
# This is just like dashmstdout with a different argument.
dashmflag=-xM
depmode=dashmstdout
fi
cygpath_u="cygpath -u -f -"
if test "$depmode" = msvcmsys; then
# This is just like msvisualcpp but w/o cygpath translation.
# Just convert the backslash-escaped backslashes to single forward
# slashes to satisfy depend.m4
cygpath_u="sed s,\\\\\\\\,/,g"
depmode=msvisualcpp
fi
case "$depmode" in
gcc3)
## gcc 3 implements dependency tracking that does exactly what
## we want. Yay! Note: for some reason libtool 1.4 doesn't like
## it if -MD -MP comes after the -MF stuff. Hmm.
## Unfortunately, FreeBSD c89 acceptance of flags depends upon
## the command line argument order; so add the flags where they
## appear in depend2.am. Note that the slowdown incurred here
## affects only configure: in makefiles, %FASTDEP% shortcuts this.
for arg
do
case $arg in
-c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
*) set fnord "$@" "$arg" ;;
esac
shift # fnord
shift # $arg
done
"$@"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
mv "$tmpdepfile" "$depfile"
;;
gcc)
## There are various ways to get dependency output from gcc. Here's
## why we pick this rather obscure method:
## - Don't want to use -MD because we'd like the dependencies to end
## up in a subdir. Having to rename by hand is ugly.
## (We might end up doing this anyway to support other compilers.)
## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
## -MM, not -M (despite what the docs say).
## - Using -M directly means running the compiler twice (even worse
## than renaming).
if test -z "$gccflag"; then
gccflag=-MD,
fi
"$@" -Wp,"$gccflag$tmpdepfile"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
echo "$object : \\" > "$depfile"
alpha=ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
## The second -e expression handles DOS-style file names with drive letters.
sed -e 's/^[^:]*: / /' \
-e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile"
## This next piece of magic avoids the `deleted header file' problem.
## The problem is that when a header file which appears in a .P file
## is deleted, the dependency causes make to die (because there is
## typically no way to rebuild the header). We avoid this by adding
## dummy dependencies for each header file. Too bad gcc doesn't do
## this for us directly.
tr ' ' '
' < "$tmpdepfile" |
## Some versions of gcc put a space before the `:'. On the theory
## that the space means something, we add a space to the output as
## well.
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
sgi)
if test "$libtool" = yes; then
"$@" "-Wp,-MDupdate,$tmpdepfile"
else
"$@" -MDupdate "$tmpdepfile"
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files
echo "$object : \\" > "$depfile"
# Clip off the initial element (the dependent). Don't try to be
# clever and replace this with sed code, as IRIX sed won't handle
# lines with more than a fixed number of characters (4096 in
# IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines;
# the IRIX cc adds comments like `#:fec' to the end of the
# dependency line.
tr ' ' '
' < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' | \
tr '
' ' ' >> "$depfile"
echo >> "$depfile"
# The second pass generates a dummy entry for each header file.
tr ' ' '
' < "$tmpdepfile" \
| sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
>> "$depfile"
else
# The sourcefile does not contain any dependencies, so just
# store a dummy comment line, to avoid errors with the Makefile
# "include basename.Plo" scheme.
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
aix)
# The C for AIX Compiler uses -M and outputs the dependencies
# in a .u file. In older versions, this file always lives in the
# current directory. Also, the AIX compiler puts `$object:' at the
# start of each line; $object doesn't have directory information.
# Version 6 uses the directory in both cases.
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
test "x$dir" = "x$object" && dir=
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.u
tmpdepfile2=$base.u
tmpdepfile3=$dir.libs/$base.u
"$@" -Wc,-M
else
tmpdepfile1=$dir$base.u
tmpdepfile2=$dir$base.u
tmpdepfile3=$dir$base.u
"$@" -M
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
do
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
# Each line is of the form `foo.o: dependent.h'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
# That's a tab and a space in the [].
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
else
# The sourcefile does not contain any dependencies, so just
# store a dummy comment line, to avoid errors with the Makefile
# "include basename.Plo" scheme.
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
icc)
# Intel's C compiler understands `-MD -MF file'. However on
# icc -MD -MF foo.d -c -o sub/foo.o sub/foo.c
# ICC 7.0 will fill foo.d with something like
# foo.o: sub/foo.c
# foo.o: sub/foo.h
# which is wrong. We want:
# sub/foo.o: sub/foo.c
# sub/foo.o: sub/foo.h
# sub/foo.c:
# sub/foo.h:
# ICC 7.1 will output
# foo.o: sub/foo.c sub/foo.h
# and will wrap long lines using \ :
# foo.o: sub/foo.c ... \
# sub/foo.h ... \
# ...
"$@" -MD -MF "$tmpdepfile"
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile"
exit $stat
fi
rm -f "$depfile"
# Each line is of the form `foo.o: dependent.h',
# or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
# Do two passes, one to just change these to
# `$object: dependent.h' and one to simply `dependent.h:'.
sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile"
# Some versions of the HPUX 10.20 sed can't process this invocation
# correctly. Breaking it into two sed invocations is a workaround.
sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" |
sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
hp2)
# The "hp" stanza above does not work with aCC (C++) and HP's ia64
# compilers, which have integrated preprocessors. The correct option
# to use with these is +Maked; it writes dependencies to a file named
# 'foo.d', which lands next to the object file, wherever that
# happens to be.
# Much of this is similar to the tru64 case; see comments there.
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
test "x$dir" = "x$object" && dir=
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
if test "$libtool" = yes; then
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir.libs/$base.d
"$@" -Wc,+Maked
else
tmpdepfile1=$dir$base.d
tmpdepfile2=$dir$base.d
"$@" +Maked
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile1" "$tmpdepfile2"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
do
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
sed -e "s,^.*\.[a-z]*:,$object:," "$tmpdepfile" > "$depfile"
# Add `dependent.h:' lines.
sed -ne '2,${
s/^ *//
s/ \\*$//
s/$/:/
p
}' "$tmpdepfile" >> "$depfile"
else
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile" "$tmpdepfile2"
;;
tru64)
# The Tru64 compiler uses -MD to generate dependencies as a side
# effect. `cc -MD -o foo.o ...' puts the dependencies into `foo.o.d'.
# At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
# dependencies in `foo.d' instead, so we check for that too.
# Subdirectories are respected.
dir=`echo "$object" | sed -e 's|/[^/]*$|/|'`
test "x$dir" = "x$object" && dir=
base=`echo "$object" | sed -e 's|^.*/||' -e 's/\.o$//' -e 's/\.lo$//'`
if test "$libtool" = yes; then
# With Tru64 cc, shared objects can also be used to make a
# static library. This mechanism is used in libtool 1.4 series to
# handle both shared and static libraries in a single compilation.
# With libtool 1.4, dependencies were output in $dir.libs/$base.lo.d.
#
# With libtool 1.5 this exception was removed, and libtool now
# generates 2 separate objects for the 2 libraries. These two
# compilations output dependencies in $dir.libs/$base.o.d and
# in $dir$base.o.d. We have to check for both files, because
# one of the two compilations can be disabled. We should prefer
# $dir$base.o.d over $dir.libs/$base.o.d because the latter is
# automatically cleaned when .libs/ is deleted, while ignoring
# the former would cause a distcleancheck panic.
tmpdepfile1=$dir.libs/$base.lo.d # libtool 1.4
tmpdepfile2=$dir$base.o.d # libtool 1.5
tmpdepfile3=$dir.libs/$base.o.d # libtool 1.5
tmpdepfile4=$dir.libs/$base.d # Compaq CCC V6.2-504
"$@" -Wc,-MD
else
tmpdepfile1=$dir$base.o.d
tmpdepfile2=$dir$base.d
tmpdepfile3=$dir$base.d
tmpdepfile4=$dir$base.d
"$@" -MD
fi
stat=$?
if test $stat -eq 0; then :
else
rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
exit $stat
fi
for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" "$tmpdepfile4"
do
test -f "$tmpdepfile" && break
done
if test -f "$tmpdepfile"; then
sed -e "s,^.*\.[a-z]*:,$object:," < "$tmpdepfile" > "$depfile"
# That's a tab and a space in the [].
sed -e 's,^.*\.[a-z]*:[ ]*,,' -e 's,$,:,' < "$tmpdepfile" >> "$depfile"
else
echo "#dummy" > "$depfile"
fi
rm -f "$tmpdepfile"
;;
#nosideeffect)
# This comment above is used by automake to tell side-effect
# dependency tracking mechanisms from slower ones.
dashmstdout)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout, regardless of -o.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove `-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
test -z "$dashmflag" && dashmflag=-M
# Require at least two characters before searching for `:'
# in the target name. This is to cope with DOS-style filenames:
# a dependency such as `c:/foo/bar' could be seen as target `c' otherwise.
"$@" $dashmflag |
sed 's:^[ ]*[^: ][^:][^:]*\:[ ]*:'"$object"'\: :' > "$tmpdepfile"
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
tr ' ' '
' < "$tmpdepfile" | \
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
dashXmstdout)
# This case only exists to satisfy depend.m4. It is never actually
# run, as this mode is specially recognized in the preamble.
exit 1
;;
makedepend)
"$@" || exit $?
# Remove any Libtool call
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# X makedepend
shift
cleared=no eat=no
for arg
do
case $cleared in
no)
set ""; shift
cleared=yes ;;
esac
if test $eat = yes; then
eat=no
continue
fi
case "$arg" in
-D*|-I*)
set fnord "$@" "$arg"; shift ;;
# Strip any option that makedepend may not understand. Remove
# the object too, otherwise makedepend will parse it as a source file.
-arch)
eat=yes ;;
-*|$object)
;;
*)
set fnord "$@" "$arg"; shift ;;
esac
done
obj_suffix=`echo "$object" | sed 's/^.*\././'`
touch "$tmpdepfile"
${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
rm -f "$depfile"
cat < "$tmpdepfile" > "$depfile"
sed '1,2d' "$tmpdepfile" | tr ' ' '
' | \
## Some versions of the HPUX 10.20 sed can't process this invocation
## correctly. Breaking it into two sed invocations is a workaround.
sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' | sed -e 's/$/ :/' >> "$depfile"
rm -f "$tmpdepfile" "$tmpdepfile".bak
;;
cpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
# Remove `-o $object'.
IFS=" "
for arg
do
case $arg in
-o)
shift
;;
$object)
shift
;;
*)
set fnord "$@" "$arg"
shift # fnord
shift # $arg
;;
esac
done
"$@" -E |
sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \
-e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' |
sed '$ s: \\$::' > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
cat < "$tmpdepfile" >> "$depfile"
sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvisualcpp)
# Important note: in order to support this mode, a compiler *must*
# always write the preprocessed file to stdout.
"$@" || exit $?
# Remove the call to Libtool.
if test "$libtool" = yes; then
while test "X$1" != 'X--mode=compile'; do
shift
done
shift
fi
IFS=" "
for arg
do
case "$arg" in
-o)
shift
;;
$object)
shift
;;
"-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
set fnord "$@"
shift
shift
;;
*)
set fnord "$@" "$arg"
shift
shift
;;
esac
done
"$@" -E 2>/dev/null |
sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
rm -f "$depfile"
echo "$object : \\" > "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s:: \1 \\:p' >> "$depfile"
echo " " >> "$depfile"
sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile"
rm -f "$tmpdepfile"
;;
msvcmsys)
# This case exists only to let depend.m4 do its work. It works by
# looking at the text of this script. This case will never be run,
# since it is checked for above.
exit 1
;;
none)
exec "$@"
;;
*)
echo "Unknown depmode $depmode" 1>&2
exit 1
;;
esac
exit 0
# Local Variables:
# mode: shell-script
# sh-indentation: 2
# eval: (add-hook 'write-file-hooks 'time-stamp)
# time-stamp-start: "scriptversion="
# time-stamp-format: "%:y-%02m-%02d.%02H"
# time-stamp-time-zone: "UTC"
# time-stamp-end: "; # UTC"
# End:
obex-data-server-0.4.6/AUTHORS 0000644 0001750 0001750 00000000041 11524724173 012663 0000000 0000000 Tadas Dailyda obex-data-server-0.4.6/configure.ac 0000644 0001750 0001750 00000011201 11546317424 014102 0000000 0000000 AC_PREREQ(2.60)
AC_INIT(obex-data-server, 0.4.6)
AM_INIT_AUTOMAKE([foreign subdir-objects])
m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
AM_CONFIG_HEADER(config.h)
AM_MAINTAINER_MODE
AC_PREFIX_DEFAULT(/usr/local)
if test "$sysconfdir" = "\${prefix}/etc" \
&& { test "$prefix" = "NONE" || test "$prefix" = "/usr" \
|| test "$prefix" = "/usr/" ; } ; then
if test "$( (uname -s) )" = "Linux" ; then
sysconfdir=/etc
fi
(
prefix=$ac_default_prefix
sysconfdir=`eval echo "$sysconfdir"`
AC_MSG_NOTICE([configuration directory is "$sysconfdir".])
AC_MSG_NOTICE([use --sysconfdir to override.])
)
fi
AC_DEFINE_UNQUOTED(CONFIGDIR, "$sysconfdir",
[Directory for the configuration files])
if test "${CFLAGS}" = ""; then
CFLAGS="-Wall -O2 -D_FORTIFY_SOURCE=2"
fi
AC_LANG_C
AC_PROG_CC
AC_PROG_INSTALL
AC_PROG_SED
PKG_PROG_PKG_CONFIG
AC_PATH_PROG(GLIB_GENMARSHAL, glib-genmarshal)
AC_PATH_PROG([DBUS_BINDING_TOOL],[dbus-binding-tool])
GLIB_REQUIRED=2.10.0
DBUS_REQUIRED=0.70
BLUEZ_REQUIRED=3.34
OPENOBEX_REQUIRED=1.3
IMAGEMAGICK_REQUIRED=6.0.0
bip_found=no
bip_type=disabled
AC_ARG_ENABLE(bip,
AC_HELP_STRING([--enable-bip=[gdk-pixbuf|magick|auto|no]],
[Enable BIP support (disabling it will break some BIP functions)]),
[bip_enable=${enableval}], [bip_enable=auto])
if test "$bip_enable" = "auto" || test "$bip_enable" = "magick"; then
PKG_CHECK_MODULES(BIP, gthread-2.0 Wand >= $IMAGEMAGICK_REQUIRED,
[bip_found=yes], [bip_found=no])
if test "$bip_found" = "yes" ; then
AC_DEFINE(USE_IMAGEMAGICK, [], [We have ImageMagick support])
bip_type="ImageMagick"
else
if test "$bip_enable" = "magick"; then
AC_MSG_ERROR([you requested BIP support using ImageMagick, but it is not available])
fi
fi
fi
if test "$bip_enable" = "auto" -a "$bip_found" = "no" || test "$bip_enable" = "gdk-pixbuf" ; then
PKG_CHECK_MODULES(BIP, gthread-2.0 gdk-pixbuf-2.0,
[bip_found=yes], [bip_found=no])
if test "$bip_found" = "yes" ; then
AC_DEFINE(USE_GDKPIXBUF, [], [We have ImageMagick support])
bip_type="gdk-pixbuf"
else
if test "$bip_enable" = "gdk-pixbuf"; then
AC_MSG_ERROR([you requested BIP support using gdk-pixbuf, but it is not available])
fi
fi
fi
AC_ARG_ENABLE(usb,
AC_HELP_STRING([--disable-usb],
[Disable USB support (breaks USB interface discovery functions)]),[usb_enable=no],
[usb_enable=yes])
if test "${usb_enable}" = "yes"; then
PKG_CHECK_MODULES(USB, libusb)
AC_SUBST(USB_CFLAGS)
AC_SUBST(USB_LIBS)
AC_DEFINE(USE_USB, [], [We have USB support])
fi
AC_ARG_ENABLE(system-config,
AC_HELP_STRING([--enable-system-config],
[install D-Bus system config file]), [
system_config_enable=${enableval}
])
AM_CONDITIONAL(SYSTEMCONFIG, test "${system_config_enable}" = "yes")
AC_ARG_ENABLE([debug],
AC_HELP_STRING([--enable-debug], [turn on debugging]),
set_debug="$enableval",[
if test -d $srcdir/.svn; then
set_debug=yes
else
set_debug=no
fi
])
if test "$set_debug" != "no"; then
CFLAGS="$CFLAGS -g -pg"
LDFLAGS="$LDFLAGS -pg"
fi
AC_ARG_ENABLE(more-warnings,
AC_HELP_STRING([--enable-more-warnings], [Maximum compiler warnings]),
set_more_warnings="$enableval",[
if test -d $srcdir/.svn; then
set_more_warnings=yes
else
set_more_warnings=no
fi
])
AC_MSG_CHECKING(for more warnings)
if test "$GCC" = "yes" -a "$set_more_warnings" != "no"; then
AC_MSG_RESULT(yes)
CFLAGS+=" -Werror -Wextra -Wcast-align"
CFLAGS+=" -Wnested-externs -Wpointer-arith"
CFLAGS+=" -Wno-unused-parameter -Wno-missing-field-initializers"
CFLAGS+=" -Wredundant-decls"
CFLAGS+=" -Wsign-compare -fno-strict-aliasing"
else
AC_MSG_RESULT(no)
fi
PKG_CHECK_MODULES(GLIB, glib-2.0 >= $GLIB_REQUIRED gobject-2.0)
AC_SUBST(GLIB_CFLAGS)
AC_SUBST(GLIB_LIBS)
PKG_CHECK_MODULES(DBUS, dbus-glib-1 >= $DBUS_REQUIRED dbus-1 >= $DBUS_REQUIRED)
AC_SUBST(DBUS_CFLAGS)
AC_SUBST(DBUS_LIBS)
PKG_CHECK_MODULES(BLUEZ, bluez >= $BLUEZ_REQUIRED)
AC_SUBST(BLUEZ_CFLAGS)
AC_SUBST(BLUEZ_LIBS)
AC_CHECK_LIB(bluetooth, sdp_extract_seqtype_safe, AC_DEFINE(USE_BLUEZ3FUNCS, [], [We are using Bluez 3.x]))
PKG_CHECK_MODULES(OPENOBEX, openobex >= $OPENOBEX_REQUIRED)
AC_SUBST(OPENOBEX_CFLAGS)
AC_SUBST(OPENOBEX_LIBS)
AC_OUTPUT([Makefile])
dnl ==========================================================================
echo "
obex-data-server $VERSION
=============================
prefix: ${prefix}
compiler: ${CC}
cflags: ${CFLAGS}
BIP imaging support: $bip_type
USB support: $usb_enable
"
obex-data-server-0.4.6/src/ 0000755 0001750 0001750 00000000000 11546317666 012500 5 0000000 0000000 obex-data-server-0.4.6/src/ods-marshal.h 0000644 0001750 0001750 00000005746 11546317666 015017 0000000 0000000
#ifndef __ods_marshal_MARSHAL_H__
#define __ods_marshal_MARSHAL_H__
#include
G_BEGIN_DECLS
/* NONE:STRING,STRING,UINT64 (src/ods-marshal.list:1) */
extern void ods_marshal_VOID__STRING_STRING_UINT64 (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
#define ods_marshal_NONE__STRING_STRING_UINT64 ods_marshal_VOID__STRING_STRING_UINT64
/* NONE:UINT64 (src/ods-marshal.list:2) */
extern void ods_marshal_VOID__UINT64 (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
#define ods_marshal_NONE__UINT64 ods_marshal_VOID__UINT64
/* NONE:STRING,STRING (src/ods-marshal.list:3) */
extern void ods_marshal_VOID__STRING_STRING (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
#define ods_marshal_NONE__STRING_STRING ods_marshal_VOID__STRING_STRING
/* NONE:STRING,STRING,STRING (src/ods-marshal.list:4) */
extern void ods_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
#define ods_marshal_NONE__STRING_STRING_STRING ods_marshal_VOID__STRING_STRING_STRING
/* NONE:STRING,BOOLEAN (src/ods-marshal.list:5) */
extern void ods_marshal_VOID__STRING_BOOLEAN (GClosure *closure,
GValue *return_value,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint,
gpointer marshal_data);
#define ods_marshal_NONE__STRING_BOOLEAN ods_marshal_VOID__STRING_BOOLEAN
G_END_DECLS
#endif /* __ods_marshal_MARSHAL_H__ */
obex-data-server-0.4.6/src/ods-session.xml 0000644 0001750 0001750 00000013666 11524724173 015413 0000000 0000000
obex-data-server-0.4.6/src/ods-capabilities.c 0000644 0001750 0001750 00000011646 11524724173 015777 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#define ODS_INS_BEGIN "{$"
#define ODS_INS_BEGIN_LEN 2
#define ODS_INS_ARG '|'
#define ODS_INS_END '}'
#define ODS_INS_ODS_VER "ODS_VER"
#define ODS_INS_MEM_FREE "MEM_FREE"
#define ODS_INS_MEM_USED "MEM_USED"
#define ODS_CAP "obex-data-server/capability.xml"
#define ODS_IMAGING_CAP "obex-data-server/imaging_capabilities.xml"
static gchar*
ods_get_variable (const gchar *var, gssize var_len,
const gchar *var_arg, gssize var_arg_len,
const gchar *set_path)
{
gchar *arg = NULL;
gchar *ret = NULL;
struct statvfs sfs;
gchar *new_path = NULL;
if (var_arg_len > 0)
arg = g_strndup (var_arg, var_arg_len);
if (!strncmp (var, ODS_INS_ODS_VER, var_len)) {
/* ODS_INS_ODS_VER {$ODS_VER} */
ret = g_strdup (VERSION);
} else if (!strncmp (var, ODS_INS_MEM_FREE, var_len)) {
/* ODS_INS_MEM_FREE {$MEM_FREE|} */
if (arg)
new_path = g_build_filename (set_path, arg, NULL);
if (statvfs (arg ? new_path : set_path, &sfs) == -1)
ret = g_strdup ("0");
else
ret = g_strdup_printf ("%" G_GUINT64_FORMAT,
(guint64)sfs.f_frsize * sfs.f_bfree);
} else if (!strncmp (var, ODS_INS_MEM_USED, var_len)) {
/* ODS_INS_MEM_USED {$MEM_USED|} */
if (arg)
new_path = g_build_filename (set_path, arg, NULL);
if (statvfs (arg ? new_path : set_path, &sfs) == -1)
ret = g_strdup ("0");
else
ret = g_strdup_printf ("%" G_GUINT64_FORMAT,
(guint64)sfs.f_frsize * (sfs.f_blocks-sfs.f_bfree));
} else {
/* unknown variable name */
ret = g_strdup ("");
}
if (arg)
g_free (arg);
if (new_path)
g_free (new_path);
return ret;
}
static gchar*
ods_insert_variables (const gchar *template, const gchar *set_path)
{
GString *output;
const gchar *templ, *templ_pos;
gchar *var = NULL;
gssize var_len = -1;
gssize var_arg_len = -1;
gint i;
g_assert (*template != '\0');
output = g_string_new ("");
templ = template;
/* search for variable to insert */
while ((templ_pos = strstr (templ, ODS_INS_BEGIN))) {
/* append everything before var to output */
output = g_string_append_len (output, templ, templ_pos-templ);
templ_pos += ODS_INS_BEGIN_LEN;
for (i=1;;i++) {
if (*(templ_pos+i) == '\0')
break;
if (*(templ_pos+i) == ODS_INS_ARG) {
var_len = i;
} else if (*(templ_pos+i) == ODS_INS_END) {
if (var_len == -1)
var_len = i;
else
var_arg_len = i-var_len-1;
break;
}
}
if (var_len == -1) {
/* invalid var definition, strip it from output */
templ = templ_pos;
break;
}
/* we got variable and argument now */
var = ods_get_variable (templ_pos, var_len,
templ_pos+var_len+1, var_arg_len,
set_path);
output = g_string_append (output, var);
g_free (var);
/* change next search position */
templ = templ_pos+i+1;
var_len = -1;
var_arg_len = -1;
}
/* append what is left */
output = g_string_append (output, templ);
return g_string_free (output, FALSE);
}
gchar*
ods_get_capability (const gchar *root_path)
{
gchar *conf_file;
gchar *contents = NULL;
GError *error = NULL;
gchar *capability = NULL;
conf_file = g_build_filename (CONFIGDIR, ODS_CAP, NULL);
if (!g_file_get_contents (conf_file, &contents, NULL, &error)) {
g_warning ("Could not read configuration file %s (%s)",
conf_file, error->message);
g_clear_error (&error);
} else {
capability = ods_insert_variables (contents, root_path);
}
g_free (conf_file);
if (contents)
g_free (contents);
return capability;
}
gchar*
ods_get_imaging_capabilities ()
{
gchar *conf_file;
gchar *contents = NULL;
GError *error = NULL;
conf_file = g_build_filename (CONFIGDIR, ODS_IMAGING_CAP, NULL);
if (!g_file_get_contents (conf_file, &contents, NULL, &error)) {
g_warning ("Could not read configuration file %s (%s)",
conf_file, error->message);
g_clear_error (&error);
}
g_free (conf_file);
return contents;
}
obex-data-server-0.4.6/src/ods-server.c 0000644 0001750 0001750 00000065357 11524724173 014664 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-common.h"
#include "ods-error.h"
#include "ods-marshal.h"
#include "ods-server.h"
#include "ods-server-dbus-glue.h"
#include "ods-server-session.h"
static GObject* ods_server_constructor (GType type, guint n_construct_params,
GObjectConstructParam *construct_params);
static void ods_server_finalize (GObject *object);
static void ods_server_attach_callback(OdsServer* server);
#define ODS_SERVER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ODS_TYPE_SERVER, OdsServerPrivate))
/* this is used for timed assignment of ServerSession fd */
#define SERVER_SESSION_INIT_TIMEOUT 250 /* timeout in milliseconds */
typedef struct OdsServerSessionCbData_ {
gint fd;
OdsServerSession *session;
} OdsServerSessionCbData;
/* this structure is used for ServerSession list */
typedef struct OdsServerSessionInfo_ {
OdsServerSession *session;
/* Bluetooth specific */
gchar *bluetooth_address;
} OdsServerSessionInfo;
struct OdsServerPrivate {
/* viariables used when disposing/stopping */
gboolean is_disposing;
gboolean is_stopping;
guint open_sessions;
gboolean socket_error;
gboolean disposed;
/* constructor properties */
gint fd; /* rfcomm device */
guint service;
gchar *owner; /* D-Bus client, who initiated this server */
/* additional options (set via SetOption) */
guint limit;
gboolean require_imaging_thumbnails;
/* io channel */
GIOChannel *io_channel;
guint io_watch;
/* other */
gchar *tty_dev;
gchar *dbus_path; /* D-Bus path for this object */
gboolean started; /* Whether server is started and accepts connections */
gchar *path; /* Server root path */
gboolean allow_write; /* Whether to allow changes in file system */
gboolean auto_accept;/* Whether incoming files should be auto-accepted */
GHashTable *session_list; /* Server client list */
};
enum {
STARTED,
STOPPED,
CLOSED,
SESSION_CREATED,
SESSION_REMOVED,
ERROR_OCCURRED,
DISPOSED,
LAST_SIGNAL
};
#define OPT_REQ_IMG_THUMBNAILS "RequireImagingThumbnails"
#define OPT_LIMIT "Limit"
static guint signals [LAST_SIGNAL] = { 0, };
/* for numbering servers */
static guint iterator = 0;
G_DEFINE_TYPE (OdsServer, ods_server, G_TYPE_OBJECT)
static void
ods_server_session_list_add (OdsServer *server, OdsServerSession *session,
bdaddr_t *bdaddr,
const gchar *dbus_path)
{
OdsServerSessionInfo *session_info;
bdaddr_t bdaddr2;
session_info = g_new0 (OdsServerSessionInfo, 1);
session_info->session = session;
if (bdaddr) {
baswap (&bdaddr2, bdaddr);
session_info->bluetooth_address = batostr (&bdaddr2);
g_message ("Bluetooth address: %s", session_info->bluetooth_address);
}
g_hash_table_insert (server->priv->session_list, g_strdup (dbus_path),
session_info);
}
static void
ods_server_session_info_free (OdsServerSessionInfo *session_info)
{
g_free (session_info->bluetooth_address);
g_free (session_info);
}
static void
server_session_disconnected_cb (OdsServerSession *server_session,
OdsServer *server)
{
gchar *session_object = NULL;
g_message ("server session closed");
g_object_get (server_session, "dbus-path", &session_object, NULL);
if (!server->priv->is_disposing && !server->priv->is_stopping)
g_hash_table_remove (server->priv->session_list, session_object);
else
server->priv->open_sessions--;
g_signal_emit (server, signals [SESSION_REMOVED], 0, session_object);
g_object_unref (server_session);
g_free (session_object);
if (server->priv->open_sessions == 0) {
if (server->priv->is_disposing) {
g_message ("Server disposed");
server->priv->disposed = TRUE;
g_signal_emit (server, signals [DISPOSED], 0);
} else if (server->priv->is_stopping) {
g_message ("Server stopped");
server->priv->is_stopping = FALSE;
server->priv->started = FALSE;
g_signal_emit (server, signals [STOPPED], 0);
if (server->priv->socket_error)
g_signal_emit (server, signals [CLOSED], 0);
} else if (server->priv->tty_dev) {
/* client disconnected from the socket, time to start listening for
* a new connection (see connect_callback). */
ods_server_attach_callback(server);
}
}
}
static void
server_session_cancelled_cb (OdsServerSession *server_session)
{
g_message ("server session cancelled");
ods_server_session_disconnect_internal (server_session);
}
static gboolean
server_session_cancel (OdsServerSession *server_session)
{
ods_server_session_cancel_internal (server_session);
return FALSE;
}
static gboolean
server_session_finalize (gpointer key, OdsServerSessionInfo *session_info,
OdsServer *server)
{
g_message ("attempting to close server session");
g_signal_connect (session_info->session, "cancelled",
G_CALLBACK (server_session_cancelled_cb), NULL);
g_idle_add ((GSourceFunc) server_session_cancel, session_info->session);
/* Even if there was nothing to cancel, we will get
* CANCELLED signal and disconnection will happen in
* session_cancelled_cb */
return TRUE;
}
static gboolean
server_session_fd_assign (OdsServerSessionCbData *data)
{
OdsServerSession *session = data->session;
g_object_set (session, "fd", data->fd, NULL);
g_free (data);
return FALSE;
}
static gboolean
connect_callback (GIOChannel *source, GIOCondition cond, gpointer data)
{
int cli_fd, srv_fd;
socklen_t size;
struct sockaddr_rc cli_addr;
bdaddr_t *bdaddr = NULL;
OdsServer *server;
OdsServerSession *session;
gchar *session_object;
OdsServerSessionCbData *cb_data;
GError *error = NULL;
gboolean ret = TRUE;
g_message ("Client connecting");
server = ODS_SERVER (data);
srv_fd = g_io_channel_unix_get_fd (source);
if (!(cond & G_IO_IN)) {
g_warning ("Error on server socket");
g_set_error (&error, ODS_ERROR, ODS_ERROR_LINK_ERROR, "Error on server socket");
ret = FALSE;
goto out;
}
if (server->priv->tty_dev) {
/* A TTY file descriptor can't accept() connection, it is the
* connection. We start out listening on it in ods-server; as soon as we
* get some input, we "disconnect" the fd from the ods-server and hand
* it off to the ods-server-session. When the session terminates
* (SIGHUP, etc), server_session_disconnected_cb will re-connect it to
* the ods-server to start waiting for the next session. */
if (!server->priv->started)
return TRUE; /* ignore requests until server is started */
ods_safe_gsource_remove (&(server->priv->io_watch));
cli_fd = srv_fd;
} else {
size = sizeof (struct sockaddr_rc);
cli_fd = accept (srv_fd, (struct sockaddr*) &cli_addr, &size);
if (!server->priv->started) {
shutdown (cli_fd, SHUT_RDWR);
close (cli_fd);
return TRUE; /* ignore requests until server is started */
}
if (server->priv->limit > 0 &&
g_hash_table_size (server->priv->session_list) == server->priv->limit) {
g_message ("ServerSession limit reached (%d), refusing connection",
server->priv->limit);
shutdown (cli_fd, SHUT_RDWR);
close (cli_fd);
return TRUE;
}
if (cli_fd < 0) {
g_message ("Error while accepting connection: %s", g_strerror (errno));
ods_error_err2gerror (errno, &error);
/* Ignore this error since we can just continue listening */
goto out;
}
}
/* To avoid race condition when client application misses TransferStarted
* signal from ServerSession object, we emit SessionCreated signal now,
* but assign fd to ServerSession (and therefore start OBEX operations)
* only after a timeout */
session = ods_server_session_new (-1, server->priv->service,
server->priv->path,
server->priv->allow_write,
server->priv->auto_accept,
server->priv->require_imaging_thumbnails,
server->priv->owner);
if (server->priv->tty_dev)
g_object_set (session, "using-tty", TRUE, NULL);
cb_data = g_new0 (OdsServerSessionCbData, 1);
cb_data->fd = cli_fd;
cb_data->session = session;
g_timeout_add (SERVER_SESSION_INIT_TIMEOUT,
(GSourceFunc) server_session_fd_assign, cb_data);
/* deal with signals */
g_signal_connect (session, "disconnected",
G_CALLBACK (server_session_disconnected_cb), server);
g_object_get (session, "dbus-path", &session_object, NULL);
g_signal_emit (server, signals [SESSION_CREATED], 0, session_object);
if (!server->priv->tty_dev) {
/* this is Bluetooth server */
bdaddr = &(cli_addr.rc_bdaddr);
}
ods_server_session_list_add (server, session, bdaddr, session_object);
g_free (session_object);
out:
if (error) {
gchar *error_name;
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred signal */
g_signal_emit (server, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
}
if (!ret) {
/* disconnect server sessions, cause there was error on server socket */
if (g_hash_table_size (server->priv->session_list) == 0) {
server->priv->started = FALSE;
g_signal_emit (server, signals [STOPPED], 0);
g_signal_emit (server, signals [CLOSED], 0);
} else {
server->priv->socket_error = TRUE;
server->priv->is_stopping = TRUE;
g_hash_table_foreach_remove (server->priv->session_list,
(GHRFunc) server_session_finalize, NULL);
/* STOPPED and CLOSED signals will be emitted in server_session_disconnected_cb */
}
g_hash_table_unref (server->priv->session_list);
}
return ret;
}
static void
ods_server_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
OdsServer *self = (OdsServer *) object;
switch (property_id) {
case ODS_SERVER_FD:
self->priv->fd = g_value_get_int (value);
break;
case ODS_SERVER_SERVICE:
self->priv->service = g_value_get_int (value);
break;
case ODS_SERVER_OWNER:
self->priv->owner = g_value_dup_string (value);
break;
case ODS_SERVER_TTY_DEV:
self->priv->tty_dev = g_value_dup_string (value);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
static void
ods_server_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
OdsServer *self = (OdsServer *) object;
switch (property_id) {
case ODS_SERVER_FD:
g_value_set_int (value, self->priv->fd);
break;
case ODS_SERVER_SERVICE:
g_value_set_int (value, self->priv->service);
break;
case ODS_SERVER_OWNER:
g_value_set_string (value, self->priv->owner);
break;
case ODS_SERVER_DBUS_PATH:
g_value_set_string (value, self->priv->dbus_path);
break;
case ODS_SERVER_PATH:
g_value_set_string (value, self->priv->path);
break;
case ODS_SERVER_TTY_DEV:
g_value_set_string (value, self->priv->tty_dev);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
break;
}
}
/**
* ods_server_class_init:
* @klass: The OdsServerClass
**/
static void
ods_server_class_init (OdsServerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->constructor = ods_server_constructor;
object_class->finalize = ods_server_finalize;
object_class->set_property = ods_server_set_property;
object_class->get_property = ods_server_get_property;
g_object_class_install_property (object_class,
ODS_SERVER_FD,
g_param_spec_int ("fd",
"", "",
0, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SERVICE,
g_param_spec_int ("service",
"", "",
0, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_OWNER,
g_param_spec_string ("owner",
"", "",
"" /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_DBUS_PATH,
g_param_spec_string ("dbus-path",
"", "",
"" /* default value */,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
ODS_SERVER_PATH,
g_param_spec_string ("path",
"", "",
"" /* default value */,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
ODS_SERVER_TTY_DEV,
g_param_spec_string ("tty-dev",
"", "",
"" /* default value */,
G_PARAM_READWRITE));
signals [STARTED] =
g_signal_new ("started",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, started),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [STOPPED] =
g_signal_new ("stopped",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, stopped),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [CLOSED] =
g_signal_new ("closed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, closed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [SESSION_CREATED] =
g_signal_new ("session-created",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, session_created),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
signals [SESSION_REMOVED] =
g_signal_new ("session-removed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, session_removed),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
signals [ERROR_OCCURRED] =
g_signal_new ("error-occurred",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, error_occurred),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
signals [DISPOSED] =
g_signal_new ("disposed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerClass, disposed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
g_type_class_add_private (klass, sizeof (OdsServerPrivate));
GError *error = NULL;
/* Init the DBus connection, per-klass */
klass->connection = dbus_g_bus_get (ODS_DBUS_BUS, &error);
if (klass->connection == NULL) {
g_warning("Unable to connect to dbus: %s", error->message);
g_clear_error (&error);
return;
}
/* &dbus_glib_ods_server_object_info is provided in the
* dbus/ods-server-dbus-glue.h file */
dbus_g_object_type_install_info (ODS_TYPE_SERVER, &dbus_glib_ods_server_object_info);
}
/**
* ods_server_init:
* @server This class instance
**/
static void
ods_server_init (OdsServer *server)
{
OdsServerClass *klass = ODS_SERVER_GET_CLASS (server);
server->priv = ODS_SERVER_GET_PRIVATE (server);
server->priv->session_list = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) ods_server_session_info_free);
/* figure out DBus object path for this instance */
server->priv->dbus_path = g_strdup_printf (ODS_SERVER_DBUS_PATH_PATTERN,
iterator);
iterator++;
dbus_g_connection_register_g_object (klass->connection,
server->priv->dbus_path,
G_OBJECT (server));
}
/**
* Common logic for ods_server_constructor and server_session_disconnected_cb:
* hooks connect_callback to the server's io channel
*/
static void ods_server_attach_callback(OdsServer* server)
{
server->priv->io_watch = g_io_add_watch(server->priv->io_channel,
G_IO_IN | G_IO_HUP | G_IO_ERR,
connect_callback, server);
}
static GObject*
ods_server_constructor (GType type, guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
OdsServer *server;
object = G_OBJECT_CLASS (ods_server_parent_class)->constructor (type,
n_construct_params,
construct_params);
server = ODS_SERVER (object);
server->priv->io_channel = g_io_channel_unix_new (server->priv->fd);
ods_server_attach_callback(server);
return object;
}
/**
* ods_server_finalize:
* @object: The object to finalize
*
* Finalize the server
**/
static void
ods_server_finalize (GObject *object)
{
OdsServer *server;
g_return_if_fail (object != NULL);
g_return_if_fail (ODS_IS_SERVER (object));
server = ODS_SERVER (object);
g_return_if_fail (server->priv != NULL);
g_return_if_fail (server->priv->disposed);
g_hash_table_unref (server->priv->session_list);
/* close server socket */
ods_safe_gsource_remove (&(server->priv->io_watch));
g_io_channel_shutdown (server->priv->io_channel, TRUE, NULL);
g_io_channel_unref(server->priv->io_channel);
close (server->priv->fd);
/* free other private variables */
g_free (server->priv->owner);
g_free (server->priv->dbus_path);
g_free (server->priv->path);
g_free (server->priv->tty_dev);
G_OBJECT_CLASS (ods_server_parent_class)->finalize (object);
}
/**
* ods_server_new:
*
* Return value: a new OdsServer object.
**/
OdsServer *
ods_server_new (gint fd, gint service, const gchar *owner)
{
OdsServer *server;
server = g_object_new (ODS_TYPE_SERVER,
"fd", fd,
"service", service,
"owner", owner,
NULL);
return ODS_SERVER (server);
}
gboolean
ods_server_start (OdsServer *server, const gchar *path, gboolean allow_write,
gboolean auto_accept, DBusGMethodInvocation *context)
{
GError *error = NULL;
/* Check caller */
if (!ods_check_caller (context, server->priv->owner))
return FALSE;
/* check if started */
if (server->priv->started) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_STARTED,
"Already started");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
if (server->priv->is_stopping || server->priv->is_disposing) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Currently stopping");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* make sure supplied path is valid */
if (!g_file_test (path, G_FILE_TEST_IS_DIR)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
g_free (server->priv->path);
server->priv->path = g_strdup (path);
server->priv->allow_write = allow_write;
server->priv->auto_accept = auto_accept;
g_warning ("Server path: %s", path);
server->priv->started = TRUE;
g_signal_emit (server, signals [STARTED], 0);
dbus_g_method_return (context);
return TRUE;
}
gboolean
ods_server_stop (OdsServer *server, DBusGMethodInvocation *context)
{
GError *error = NULL;
/* Check caller */
if (!ods_check_caller (context, server->priv->owner))
return FALSE;
/* check if not started */
if (!server->priv->started) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_STARTED,
"Not started");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* disconnect server sessions */
if (g_hash_table_size (server->priv->session_list) == 0) {
server->priv->started = FALSE;
g_signal_emit (server, signals [STOPPED], 0);
} else {
server->priv->is_stopping = TRUE;
g_hash_table_foreach_remove (server->priv->session_list,
(GHRFunc) server_session_finalize, NULL);
/* STOPPED signal will be emitted in server_session_disconnected_cb */
}
g_hash_table_unref (server->priv->session_list);
server->priv->session_list = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) ods_server_session_info_free);
dbus_g_method_return (context);
return TRUE;
}
gboolean
ods_server_close (OdsServer *server, DBusGMethodInvocation *context)
{
/* Check caller */
if (!ods_check_caller (context, server->priv->owner))
return FALSE;
if (server->priv->started)
g_signal_emit (server, signals [STOPPED], 0);
g_signal_emit (server, signals [CLOSED], 0);
/* server socket will be closed when this GObject is finalized */
dbus_g_method_return (context);
return TRUE;
}
/* Not exposed through DBUS, used internally */
void
ods_server_dispose (OdsServer *server)
{
g_return_if_fail (server != NULL);
g_return_if_fail (ODS_IS_SERVER (server));
g_return_if_fail (server->priv != NULL);
if (server->priv->disposed)
return;
g_message ("Disposing Server");
server->priv->is_disposing = TRUE;
/* check if there is nothing to dispose */
if (g_hash_table_size (server->priv->session_list) == 0) {
g_message ("Server disposed at once");
server->priv->disposed = TRUE;
g_signal_emit (server, signals [DISPOSED], 0);
} else {
/* disconnect server sessions */
server->priv->open_sessions = g_hash_table_size (server->priv->session_list);
g_hash_table_foreach_remove (server->priv->session_list,
(GHRFunc) server_session_finalize, NULL);
/* when session_list becomes empty in server_session_disconnected callback
* "disposed" signal will be emitted */
}
}
gboolean
ods_server_is_started (OdsServer *server)
{
return server->priv->started;
}
gboolean
ods_server_set_option (OdsServer *server, const gchar *name, GValue *value,
DBusGMethodInvocation *context)
{
GError *error = NULL;
/* Check caller */
if (!ods_check_caller (context, server->priv->owner))
return FALSE;
if (!g_ascii_strncasecmp (name, OPT_REQ_IMG_THUMBNAILS, strlen (name))) {
/* require-imaging-thumbnails */
if (!G_VALUE_HOLDS_BOOLEAN (value)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid value for require-imaging-thumbnails");
goto out;
}
server->priv->require_imaging_thumbnails = g_value_get_boolean (value);
} else if (!g_ascii_strncasecmp (name, OPT_LIMIT, strlen (name))) {
/* limit */
if (!G_VALUE_HOLDS_UINT (value)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid value for limit");
goto out;
}
server->priv->limit = g_value_get_uint (value);
} else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Unknown option");
goto out;
}
out:
if (error) {
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
dbus_g_method_return (context);
return TRUE;
}
GHashTable *
ods_server_get_server_session_info (OdsServer *server, gchar *session_object)
{
GHashTable *info;
OdsServerSessionInfo *session_info;
info = g_hash_table_new ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
session_info = g_hash_table_lookup (server->priv->session_list, session_object);
if (session_info && session_info->bluetooth_address) {
g_hash_table_insert (info, "BluetoothAddress",
g_strdup (session_info->bluetooth_address));
}
return info;
}
gchar**
ods_server_get_server_session_list (OdsServer *server)
{
return ods_hash_table_keys2strv (server->priv->session_list);
}
obex-data-server-0.4.6/src/ods-usb.h 0000644 0001750 0001750 00000001646 11524724173 014143 0000000 0000000 #include "config.h"
#ifdef USE_USB
#include
#include
/** USB-specific OBEX service information
* provided by optional Service Identification Functional Descriptor
* (CDC WMC specification section 6.5.2.5)
*/
typedef struct {
/* Role bit mask: bit 0 is set if client, unset if server */
guint8 role;
/* Service UUID */
guint8 uuid[16];
/** Service version */
guint16 version;
/** Set if the service provides/expects
* an OBEX Default Server (spec section 6.5.2.5.2) */
int is_default_uuid;
} ods_usb_intf_service_t;
struct ods_usb_info {
char *manufacturer;
char *product;
char *serial;
char *configuration;
char *control_interface;
char *data_interface_idle;
char *data_interface_active;
ods_usb_intf_service_t *service;
char *path;
};
typedef struct ods_usb_info ods_usb_info;
void ods_usbobex_free_interfaces(GList *list);
GList *ods_usbobex_find_interfaces(void);
#endif /* USE_USB */
obex-data-server-0.4.6/src/ods-server-session.h 0000644 0001750 0001750 00000007707 11524724173 016345 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_SERVER_SESSION_H
#define __ODS_SERVER_SESSION_H
#include
#include
G_BEGIN_DECLS
#define ODS_TYPE_SERVER_SESSION (ods_server_session_get_type ())
#define ODS_SERVER_SESSION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ODS_TYPE_SERVER_SESSION, OdsServerSession))
#define ODS_SERVER_SESSION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), ODS_TYPE_SERVER_SESSION, OdsServerSessionClass))
#define ODS_IS_SERVER_SESSION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ODS_TYPE_SERVER_SESSION))
#define ODS_IS_SERVER_SESSION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ODS_TYPE_SERVER_SESSION))
#define ODS_SERVER_SESSION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ODS_TYPE_SERVER_SESSION, OdsServerSessionClass))
enum {
ODS_SERVER_SESSION_FD = 1,
ODS_SERVER_SESSION_SERVICE,
ODS_SERVER_SESSION_PATH,
ODS_SERVER_SESSION_ALLOW_WRITE,
ODS_SERVER_SESSION_AUTO_ACCEPT,
ODS_SERVER_SESSION_REQUIRE_IMAGING_THUMBNAILS,
ODS_SERVER_SESSION_USING_TTY,
ODS_SERVER_SESSION_OWNER,
ODS_SERVER_SESSION_DBUS_PATH
};
typedef struct OdsServerSessionPrivate OdsServerSessionPrivate;
typedef struct
{
GObject parent;
OdsServerSessionPrivate *priv;
} OdsServerSession;
typedef struct
{
GObjectClass parent_class;
void (* cancelled) (OdsServerSession *server_session);
void (* disconnected) (OdsServerSession *server_session);
void (* transfer_started) (OdsServerSession *server_session,
const gchar *filename,
const gchar *local_path,
guint64 total_bytes);
void (* transfer_progress) (OdsServerSession *server_session,
guint64 bytes_transferred);
void (* transfer_completed) (OdsServerSession *server_session);
void (* error_occurred) (OdsServerSession *server_session,
const gchar *error_name,
const gchar *error_message);
void (* remote_display_requested) (OdsServerSession *server_session,
const gchar *filename);
DBusGConnection *connection;
} OdsServerSessionClass;
GType ods_server_session_get_type (void);
OdsServerSession *ods_server_session_new (gint fd,
gint service,
const gchar *path,
gboolean allow_write,
gboolean auto_accept,
gboolean require_imaging_thumbnails,
const gchar *owner);
gboolean ods_server_session_accept (OdsServerSession *server_session,
DBusGMethodInvocation *context);
gboolean ods_server_session_reject (OdsServerSession *server_session,
DBusGMethodInvocation *context);
void ods_server_session_disconnect_internal (OdsServerSession *server_session);
gboolean ods_server_session_disconnect (OdsServerSession *server_session,
DBusGMethodInvocation *context);
GHashTable *ods_server_session_get_transfer_info (OdsServerSession *server_session);
gboolean ods_server_session_cancel_internal (OdsServerSession *server_session);
gboolean ods_server_session_cancel (OdsServerSession *server_session,
DBusGMethodInvocation *context);
G_END_DECLS
#endif /* __ODS_SERVER_SESSION_H */
obex-data-server-0.4.6/src/ods-session.h 0000644 0001750 0001750 00000017021 11524724173 015027 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_SESSION_H
#define __ODS_SESSION_H
#include
#include
G_BEGIN_DECLS
#define ODS_TYPE_SESSION (ods_session_get_type ())
#define ODS_SESSION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ODS_TYPE_SESSION, OdsSession))
#define ODS_SESSION_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), ODS_TYPE_SESSION, OdsSessionClass))
#define ODS_IS_SESSION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ODS_TYPE_SESSION))
#define ODS_IS_SESSION_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ODS_TYPE_SESSION))
#define ODS_SESSION_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ODS_TYPE_SESSION, OdsSessionClass))
enum {
ODS_SESSION_FD = 1,
ODS_SESSION_SERVICE,
ODS_SESSION_OWNER,
ODS_SESSION_DBUS_PATH,
ODS_SESSION_IMAGING_FEATURE,
ODS_SESSION_IMAGING_SDP_DATA,
ODS_SESSION_TARGET_UUID,
ODS_SESSION_USBINTFNUM
};
typedef struct OdsSessionPrivate OdsSessionPrivate;
typedef struct
{
GObject parent;
OdsSessionPrivate *priv;
} OdsSession;
typedef struct
{
GObjectClass parent_class;
void (* cancelled) (OdsSession *session);
void (* connect_result_internal) (OdsSession *session,
const gchar *error_name,
const gchar *error_message);
void (* disconnected) (OdsSession *session);
void (* closed) (OdsSession *session);
void (* transfer_started) (OdsSession *session,
const gchar *filename,
const gchar *local_path,
guint64 total_bytes);
void (* transfer_progress) (OdsSession *session,
guint64 bytes_transferred);
void (* transfer_completed) (OdsSession *session);
void (* error_occurred) (OdsSession *session,
const gchar *error_name,
const gchar *error_message);
void (* image_handle_received)(OdsSession *session,
const gchar *image_handle,
gboolean thumbnail_requested);
DBusGConnection *connection;
} OdsSessionClass;
GType ods_session_get_type (void);
OdsSession *ods_session_new (gint fd,
gint usb_interface_number,
gint service,
const gchar *owner,
const gchar *target_uuid);
gint ods_session_disconnect_internal (OdsSession *session,
GError **error);
gboolean ods_session_disconnect (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_close (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_change_current_folder (OdsSession *session,
const gchar *path,
DBusGMethodInvocation *context);
gboolean ods_session_change_current_folder_backward (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_change_current_folder_to_root (OdsSession *session,
DBusGMethodInvocation *context);
gchar *ods_session_get_current_path (OdsSession *session);
gboolean ods_session_copy_remote_file (OdsSession *session,
const gchar *remote_filename,
const gchar *local_path,
DBusGMethodInvocation *context);
gboolean ods_session_copy_remote_file_by_type (OdsSession *session,
const gchar *type,
const gchar *local_path,
DBusGMethodInvocation *context);
gboolean ods_session_create_folder (OdsSession *session,
const gchar *folder_name,
DBusGMethodInvocation *context);
gboolean ods_session_retrieve_folder_listing (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_get_capability (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_get_imaging_capabilities (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_send_file_ext (OdsSession *session,
const gchar *local_path,
const gchar *remote_filename,
const gchar *type,
DBusGMethodInvocation *context);
gboolean ods_session_send_file (OdsSession *session,
const gchar *local_path,
DBusGMethodInvocation *context);
gboolean ods_session_set_transfer_hints (OdsSession *session,
const gchar *fifo,
const gchar *remote_filename,
const gchar *type,
guint64 size,
gint64 mtime,
gint64 ctime,
DBusGMethodInvocation *context);
gboolean ods_session_delete_remote_file (OdsSession *session,
const gchar *remote_filename,
DBusGMethodInvocation *context);
gboolean ods_session_remote_copy (OdsSession *session,
const gchar *remote_source,
const gchar *remote_destination,
DBusGMethodInvocation *context);
gboolean ods_session_remote_move (OdsSession *session,
const gchar *remote_source,
const gchar *remote_destination,
DBusGMethodInvocation *context);
gboolean ods_session_get_image_info (OdsSession *session,
const gchar *local_path,
DBusGMethodInvocation *context);
gboolean ods_session_put_image (OdsSession *session,
const gchar *local_path,
DBusGMethodInvocation *context);
gboolean ods_session_put_image_resized (OdsSession *session,
const gchar *local_path,
guint16 width,
guint16 height,
const gchar *encoding,
const gchar *transformation,
DBusGMethodInvocation *context);
gboolean ods_session_put_linked_attachment (OdsSession *session,
const gchar *image_handle,
const gchar *local_path,
const gchar *content_type,
const gchar *charset,
DBusGMethodInvocation *context);
gboolean ods_session_remote_display_select_image (OdsSession *session,
const gchar *image_handle,
DBusGMethodInvocation *context);
gboolean ods_session_remote_display_show_current_image (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_remote_display_show_next_image (OdsSession *session,
DBusGMethodInvocation *context);
gboolean ods_session_remote_display_show_previous_image (OdsSession *session,
DBusGMethodInvocation *context);
GHashTable *ods_session_get_transfer_info (OdsSession *session);
gboolean ods_session_is_busy (OdsSession *session);
gboolean ods_session_cancel_internal (OdsSession *session);
gboolean ods_session_cancel (OdsSession *session,
DBusGMethodInvocation *context);
G_END_DECLS
#endif /* __ODS_SESSION_H */
obex-data-server-0.4.6/src/ods-bluez.c 0000644 0001750 0001750 00000052232 11524724173 014463 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-bluez.h"
#include "ods-common.h"
#include "ods-error.h"
static gboolean sdp_initiate_search (OdsBluezCancellable *ctxt);
static GHashTable *sdp_session_list = NULL;
typedef struct SdpSessionRecords_ {
sdp_session_t *session;
guint rec_count;
} SdpSessionRecords;
static void
ods_bluez_cancellable_free (OdsBluezCancellable *cb_data)
{
g_io_channel_unref (cb_data->io_channel);
sdp_close (cb_data->session);
g_free (cb_data->imagingdata);
g_free (cb_data);
}
static gboolean
client_socket_connect_cb (GIOChannel *io_channel, GIOCondition cond,
OdsBluezCancellable *cb_data)
{
OdsBluezFunc cb = cb_data->cb;
gint fd;
gint ret_fd = -1;
GError *error = NULL;
fd = g_io_channel_unix_get_fd (io_channel);
/* Evaluate the connection condition */
if (cond == G_IO_OUT) {
/* Connection successful */
ret_fd = fd;
} else if (cond == (G_IO_OUT | G_IO_HUP)) {
/* The connection timed out. */
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_TIMEOUT, "Connection timed out");
} else if (cond == (G_IO_OUT | G_IO_HUP | G_IO_ERR)) {
/* The connection was refused */
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_REFUSED, "Connection refused");
} else {
/* A generic unknown error occured during the connection attempt. */
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED, "Connection failed");
}
if (ret_fd != -1)
g_message ("Connected");
else {
close (fd);
g_message ("Failed to connect");
}
cb (ret_fd, cb_data->channel, cb_data->imagingdata, error, cb_data->cb_data);
ods_bluez_cancellable_free (cb_data);
g_clear_error (&error);
return FALSE;
}
static void
rfcomm_connect (OdsBluezCancellable *cb_data, gint channel)
{
OdsBluezFunc cb = cb_data->cb;
GError *error = NULL;
struct sockaddr_rc addr;
int fd = -1;
GIOChannel *io_channel = NULL;
/* Create socket and start connecting */
fd = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
if (fd < 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Could not create socket");
goto err;
}
memset (&addr, 0, sizeof(addr));
/* source address */
addr.rc_family = AF_BLUETOOTH;
bacpy (&addr.rc_bdaddr, &cb_data->source_address);
if (bind (fd, (struct sockaddr *) &addr, sizeof (addr)) < 0) {
g_set_error (&error, ODS_ERROR,
ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Binding to local device failed (errno: %d)", errno);
goto err;
}
memset (&addr, 0, sizeof(addr));
/* destination address */
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = channel;
bacpy (&addr.rc_bdaddr, &cb_data->target_address);
/* Use non-blocking connect */
fcntl (fd, F_SETFL, O_NONBLOCK);
io_channel = g_io_channel_unix_new (fd);
if (connect (fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
/* BlueZ returns EAGAIN eventhough it should return EINPROGRESS */
if (!(errno == EAGAIN || errno == EINPROGRESS)) {
g_set_error (&error, ODS_ERROR,
ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Connecting to remote device failed");
goto err;
}
g_message ("Connect in progress");
cb_data->io_watch = g_io_add_watch (io_channel,
G_IO_OUT | G_IO_ERR | G_IO_NVAL | G_IO_HUP,
(GIOFunc) client_socket_connect_cb, cb_data);
cb_data->fd = fd;
} else {
/* Connect succeeded with first try */
g_message ("Connect on first try");
client_socket_connect_cb (io_channel, G_IO_OUT, cb_data);
}
g_io_channel_unref (io_channel);
return;
err:
if (io_channel)
g_io_channel_unref (io_channel);
if (fd >= 0)
close (fd);
cb (-1, cb_data->channel, cb_data->imagingdata, error, cb_data->cb_data);
ods_bluez_cancellable_free (cb_data);
g_clear_error (&error);
}
static void
sdp_get_channel (sdp_record_t *sdp_record,
OdsBluezCancellable *cb_data)
{
OdsBluezFunc cb = cb_data->cb;
GError *error = NULL;
sdp_list_t *protos = NULL;
gint channel = -1;
g_message ("getting RFCOMM channel");
/* get channel for this service */
if (sdp_get_access_protos (sdp_record, &protos) != 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not get service channel");
goto err;
}
channel = sdp_get_proto_port (protos, RFCOMM_UUID);
cb_data->channel = channel;
if (cb_data->uuid.value.uuid16 == IMAGING_RESPONDER_SVCLASS_ID) {
/* BIP only */
sdp_data_t *sdpdata;
cb_data->imagingdata = g_new0 (ImagingSdpData, 1);
sdpdata = sdp_data_get (sdp_record, SDP_ATTR_SUPPORTED_CAPABILITIES);
cb_data->imagingdata->supp_capabilities = sdpdata->val.uint8;
g_message ("supp_capabilities: %d", cb_data->imagingdata->supp_capabilities);
sdpdata = sdp_data_get (sdp_record, SDP_ATTR_SUPPORTED_FEATURES);
cb_data->imagingdata->supp_features = sdpdata->val.uint16;
g_message ("supp_features: %d", cb_data->imagingdata->supp_features);
sdpdata = sdp_data_get (sdp_record, SDP_ATTR_SUPPORTED_FUNCTIONS);
cb_data->imagingdata->supp_functions = sdpdata->val.uint32;
g_message ("supp_funcs: %d", cb_data->imagingdata->supp_functions);
sdpdata = sdp_data_get (sdp_record, SDP_ATTR_TOTAL_IMAGING_DATA_CAPACITY);
cb_data->imagingdata->data_capacity = sdpdata->val.uint64;
g_message ("data_cap: %" G_GUINT64_FORMAT, cb_data->imagingdata->data_capacity);
if (!(cb_data->imaging_feature & cb_data->imagingdata->supp_features)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Selected imaging feature not supported");
goto err;
}
}
if (protos) {
sdp_list_foreach (protos, (sdp_list_func_t)sdp_list_free, 0);
sdp_list_free (protos, 0);
}
rfcomm_connect (cb_data, channel);
return;
err:
cb (-1, cb_data->channel, cb_data->imagingdata, error, cb_data->cb_data);
ods_bluez_cancellable_free (cb_data);
g_clear_error (&error);
}
static void sdp_search_completed_cb (uint8_t type, uint16_t status,
uint8_t *rsp, size_t size,
void *user_data)
{
OdsBluezCancellable *ctxt = user_data;
OdsBluezFunc cb = ctxt->cb;
sdp_list_t *recs = NULL;
guint scanned;
int seqlen = 0, bytesleft = size;
uint8_t dataType;
GError *error = NULL;
if (status || type != SDP_SVC_SEARCH_ATTR_RSP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed");
goto done;
}
g_message ("SDP search completed");
#ifdef USE_BLUEZ3FUNCS
/* Using Bluez 3.x */
scanned = sdp_extract_seqtype_safe(rsp, bytesleft, &dataType, &seqlen);
#else
/* Using Bluez 4.x */
scanned = sdp_extract_seqtype(rsp, bytesleft, &dataType, &seqlen);
#endif /* USE_BLUEZ3FUNCS */
if (!scanned) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed");
goto done;
}
rsp += scanned;
bytesleft -= scanned;
do {
sdp_record_t *rec;
int recsize;
recsize = 0;
#ifdef USE_BLUEZ3FUNCS
/* Using Bluez 3.x */
rec = sdp_extract_pdu_safe(rsp, bytesleft, &recsize);
#else
/* Using Bluez 4.x */
rec = sdp_extract_pdu(rsp, bytesleft, &recsize);
#endif /* USE_BLUEZ3FUNCS */
if (!rec)
break;
if (!recsize) {
sdp_record_free(rec);
break;
}
scanned += recsize;
rsp += recsize;
bytesleft -= recsize;
recs = sdp_list_append(recs, rec);
} while (scanned < size && bytesleft > 0);
if (sdp_list_len (recs) == 0) {
g_message ("no SDP records found");
if (!memcmp (&ctxt->uuid.value.uuid128, OBEX_NOKIAFTP_UUID,
sizeof(uint128_t))) {
g_message ("Using standard OBEX FTP uuid");
sdp_uuid16_create (&ctxt->uuid, OBEX_FILETRANS_SVCLASS_ID);
if (!sdp_initiate_search (ctxt))
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed");
} else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Service not supported by remote device");
}
} else {
sdp_record_print (recs->data);
sdp_get_channel (recs->data, ctxt);
}
done:
if (error) {
cb (-1, ctxt->channel, ctxt->imagingdata, error, ctxt->cb_data);
ods_bluez_cancellable_free (ctxt);
g_clear_error (&error);
}
if (recs)
sdp_list_free(recs, (sdp_free_func_t) sdp_record_free);
}
static gboolean sdp_search_process_cb (GIOChannel *chan,
GIOCondition cond, void *user_data)
{
OdsBluezCancellable *ctxt = user_data;
OdsBluezFunc cb = ctxt->cb;
GError *error = NULL;
g_message ("SDP search process");
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed");
cb (-1, ctxt->channel, ctxt->imagingdata, error, ctxt->cb_data);
ods_bluez_cancellable_free (ctxt);
g_clear_error (&error);
return FALSE;
}
if (sdp_process(ctxt->session) < 0) {
/* search finished and search_completed_cb was called */
return FALSE;
}
return TRUE;
}
static gboolean sdp_initiate_search (OdsBluezCancellable *ctxt)
{
sdp_list_t *search, *attrids;
uint32_t range = 0x0000ffff;
gboolean ret = TRUE;
/* Set callback responsible for calling sdp_process */
ctxt->io_watch = g_io_add_watch(ctxt->io_channel,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
sdp_search_process_cb, ctxt);
search = sdp_list_append(NULL, &ctxt->uuid);
attrids = sdp_list_append(NULL, &range);
if (sdp_service_search_attr_async(ctxt->session,
search, SDP_ATTR_REQ_RANGE, attrids) < 0) {
ods_safe_gsource_remove (&ctxt->io_watch);
ret = FALSE;
}
sdp_list_free(attrids, NULL);
sdp_list_free(search, NULL);
return ret;
}
static gboolean sdp_connect_watch (GIOChannel *chan, GIOCondition cond,
gpointer user_data)
{
OdsBluezCancellable *ctxt = user_data;
socklen_t len;
int sk, err = 0;
GError *error = NULL;
OdsBluezFunc cb = ctxt->cb;
sk = g_io_channel_unix_get_fd(chan);
len = sizeof(err);
if (getsockopt(sk, SOL_SOCKET, SO_ERROR, &err, &len) < 0)
goto failed;
if (err != 0)
goto failed;
g_message ("Connected SDP session");
if (sdp_set_notify(ctxt->session, sdp_search_completed_cb, ctxt) < 0)
goto failed;
if (!sdp_initiate_search (ctxt))
goto failed;
return FALSE;
failed:
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed (%s)",
err ? strerror(err) : "Could not start search");
cb (-1, ctxt->channel, ctxt->imagingdata, error, ctxt->cb_data);
ods_bluez_cancellable_free (ctxt);
g_clear_error (&error);
return FALSE;
}
OdsBluezCancellable*
ods_bluez_get_client_socket (const bdaddr_t *dst,
const bdaddr_t *src,
const uuid_t *uuid,
guint imaging_feature,
gint channel,
OdsBluezFunc func,
gpointer data)
{
OdsBluezCancellable *cb_data;
cb_data = g_new0 (OdsBluezCancellable, 1);
cb_data->cb = func;
cb_data->cb_data = data;
bacpy (&cb_data->target_address, dst);
bacpy (&cb_data->source_address, src);
cb_data->imaging_feature = imaging_feature;
cb_data->channel = -1;
cb_data->fd = -1;
/* Discover channel for needed service only if we don't know it yet */
if (channel == 0) {
cb_data->session = sdp_connect (src, dst, SDP_NON_BLOCKING);
if (!cb_data->session) {
ods_bluez_cancellable_free (cb_data);
return NULL;
}
cb_data->io_channel = g_io_channel_unix_new (
sdp_get_socket (cb_data->session));
cb_data->io_watch = g_io_add_watch (cb_data->io_channel,
G_IO_OUT | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
sdp_connect_watch, cb_data);
/* From Johan Hedberg:
*
* some Nokia Symbian phones have two OBEX FTP services: one
* identified with the normal UUID and another with a Nokia specific
* 128 bit UUID. The service found behind the normal identifier is
* very limited in features on these phones while the other one
* supports full OBEX FTP (don't ask me why).
*/
/* if FTP was requested, use NOKIAFTP instead,
* if it isn't found we retreat to FTP in get_remote_service_handles_cb */
if (uuid->value.uuid16 == OBEX_FILETRANS_SVCLASS_ID ||
!memcmp(&uuid->value.uuid128, OBEX_FTP_UUID, sizeof(uint128_t))) {
g_message ("FTP uuid selected, first checking for Nokia OBEX PC Suite Services uuid");
sdp_uuid128_create (&cb_data->uuid, OBEX_NOKIAFTP_UUID);
} else
memcpy (&cb_data->uuid, uuid, sizeof (uuid_t));
} else {
/* skip SDP requests and connect to specified RFCOMM channel */
cb_data->channel = channel;
rfcomm_connect (cb_data, channel);
}
return cb_data;
}
void
ods_bluez_cancel_get_client_socket (OdsBluezCancellable *cancel)
{
OdsBluezFunc cb = cancel->cb;
GError *error = NULL;
/* cancel connecting */
if (cancel->io_watch > 0) {
if (cancel->fd >= 0)
close (cancel->fd);
ods_safe_gsource_remove (&cancel->io_watch);
}
/* callback */
g_set_error (&error, ODS_ERROR, ODS_ERROR_CANCELLED,
"Cancelled by DBus client");
cb (-1, cancel->channel, cancel->imagingdata, error, cancel->cb_data);
g_clear_error (&error);
ods_bluez_cancellable_free (cancel);
}
gint
ods_bluez_get_server_socket (const gchar *address, guint8 channel)
{
struct sockaddr_rc addr;
gint fd = -1;
fd = socket (AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM);
if (fd < 0)
goto err;
memset (&addr, 0, sizeof(addr));
addr.rc_family = AF_BLUETOOTH;
addr.rc_channel = channel;
str2ba (address, &addr.rc_bdaddr);
if (bind (fd, (struct sockaddr *) &addr, sizeof (addr)) < 0) {
goto err;
}
if (listen (fd, 1) < 0) {
goto err;
}
return fd;
err:
if (fd >= 0)
close (fd);
return -1;
}
static sdp_session_t*
sdp_session_get (const gchar *device, gboolean create_new)
{
SdpSessionRecords *recs;
sdp_session_t *session;
bdaddr_t src;
if (sdp_session_list &&
(recs = g_hash_table_lookup (sdp_session_list, device))) {
return recs->session;
}
if (!create_new)
return NULL;
str2ba (device, &src);
session = sdp_connect (&src, BDADDR_LOCAL, SDP_RETRY_IF_BUSY);
if (!session) {
g_warning ("Couldn't connect to SDP server");
return NULL;
}
return session;
}
static void
sdp_session_list_add (const gchar *device, sdp_session_t *session)
{
SdpSessionRecords *recs;
if (!sdp_session_list) {
sdp_session_list = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, g_free);
}
if (!(recs = g_hash_table_lookup (sdp_session_list, device))) {
recs = g_new0 (SdpSessionRecords, 1);
recs->session = session;
recs->rec_count = 1;
g_hash_table_insert (sdp_session_list, g_strdup (device), recs);
} else {
recs->rec_count++;
}
}
static void
sdp_session_list_remove (const gchar *device)
{
SdpSessionRecords *recs;
if (!sdp_session_list)
return;
if (!(recs = g_hash_table_lookup (sdp_session_list, device)))
return;
recs->rec_count--;
if (recs->rec_count < 1) {
sdp_close (recs->session);
g_hash_table_remove (sdp_session_list, device);
}
}
static guint32
add_bin_service_record (const gchar *device, sdp_record_t *rec)
{
sdp_session_t *session;
bdaddr_t src;
gint ret;
str2ba (device, &src);
session = sdp_session_get (device, TRUE);
if (!session)
return 0;
ret = sdp_device_record_register (session, &src, rec, 0);
if (ret < 0) {
g_warning("Failed to register sdp record, ret: %i", ret);
return 0;
}
sdp_session_list_add (device, session);
return rec->handle;
}
guint32
ods_bluez_add_service_record (const gchar *device, gint service,
ImagingSdpData *imagingdata)
{
guint32 ret;
/* vars that differ according to service */
guint8 chan;
guint16 svclass_id_;
guint16 profile_id_;
gchar *desc;
/* --- */
sdp_list_t *svclass_id, *pfseq, *apseq, *root;
uuid_t root_uuid, svclass_uuid, l2cap_uuid, rfcomm_uuid, obex_uuid;
sdp_profile_desc_t profile[1];
sdp_list_t *aproto, *proto[3];
sdp_data_t *channel;
/* only for OPP */
uint8_t formats[] = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0xFF };
void *dtds[sizeof(formats)], *values[sizeof(formats)];
guint32 i;
uint8_t dtd = SDP_UINT8;
sdp_data_t *sflist;
/* --- */
/* only for BIP */
sdp_data_t *supp_cap, *supp_feat, *supp_func, *data_cap;
/* --- */
sdp_record_t rec;
switch (service) {
case ODS_SERVICE_OPP:
chan = ODS_OPP_RFCOMM_CHANNEL;
svclass_id_ = OBEX_OBJPUSH_SVCLASS_ID;
profile_id_ = OBEX_OBJPUSH_PROFILE_ID;
desc = "OBEX Object Push";
break;
case ODS_SERVICE_FTP:
chan = ODS_FTP_RFCOMM_CHANNEL;
svclass_id_ = OBEX_FILETRANS_SVCLASS_ID;
profile_id_ = OBEX_FILETRANS_PROFILE_ID;
desc = "OBEX File Transfer";
break;
case ODS_SERVICE_PBAP:
chan = ODS_PBAP_RFCOMM_CHANNEL;
svclass_id_ = PBAP_PSE_SVCLASS_ID;
profile_id_ = PBAP_PSE_PROFILE_ID;
desc = "OBEX Phonebook Access";
break;
case ODS_SERVICE_BIP:
chan = ODS_BIP_RFCOMM_CHANNEL;
svclass_id_ = IMAGING_RESPONDER_SVCLASS_ID;
profile_id_ = IMAGING_PROFILE_ID;
desc = "Imaging";
break;
default:
return 0;
}
memset (&rec, 0, sizeof(sdp_record_t));
rec.handle = 0xffffffff;
sdp_uuid16_create (&root_uuid, PUBLIC_BROWSE_GROUP);
root = sdp_list_append (0, &root_uuid);
sdp_set_browse_groups (&rec, root);
sdp_uuid16_create (&svclass_uuid, svclass_id_);
svclass_id = sdp_list_append (0, &svclass_uuid);
sdp_set_service_classes (&rec, svclass_id);
sdp_uuid16_create (&profile[0].uuid, profile_id_);
profile[0].version = 0x0100;
pfseq = sdp_list_append (0, profile);
sdp_set_profile_descs (&rec, pfseq);
sdp_uuid16_create (&l2cap_uuid, L2CAP_UUID);
proto[0] = sdp_list_append (0, &l2cap_uuid);
apseq = sdp_list_append (0, proto[0]);
sdp_uuid16_create (&rfcomm_uuid, RFCOMM_UUID);
proto[1] = sdp_list_append (0, &rfcomm_uuid);
channel = sdp_data_alloc (SDP_UINT8, &chan);
proto[1] = sdp_list_append (proto[1], channel);
apseq = sdp_list_append (apseq, proto[1]);
sdp_uuid16_create (&obex_uuid, OBEX_UUID);
proto[2] = sdp_list_append (0, &obex_uuid);
apseq = sdp_list_append (apseq, proto[2]);
aproto = sdp_list_append (0, apseq);
sdp_set_access_protos (&rec, aproto);
if (service == ODS_SERVICE_OPP) {
for (i = 0; i < sizeof(formats); i++) {
dtds[i] = &dtd;
values[i] = &formats[i];
}
sflist = sdp_seq_alloc (dtds, values, sizeof(formats));
sdp_attr_add (&rec, SDP_ATTR_SUPPORTED_FORMATS_LIST, sflist);
} else if (service == ODS_SERVICE_BIP) {
g_assert (imagingdata != NULL);
supp_cap = sdp_data_alloc (SDP_UINT8, &imagingdata->supp_capabilities);
supp_feat = sdp_data_alloc (SDP_UINT16, &imagingdata->supp_features);
supp_func = sdp_data_alloc (SDP_UINT32, &imagingdata->supp_functions);
data_cap = sdp_data_alloc (SDP_UINT64, &imagingdata->data_capacity);
sdp_attr_add (&rec, SDP_ATTR_SUPPORTED_CAPABILITIES, supp_cap);
sdp_attr_add (&rec, SDP_ATTR_SUPPORTED_FEATURES, supp_feat);
sdp_attr_add (&rec, SDP_ATTR_SUPPORTED_FUNCTIONS, supp_func);
sdp_attr_add (&rec, SDP_ATTR_TOTAL_IMAGING_DATA_CAPACITY, data_cap);
}
sdp_set_info_attr (&rec, desc, 0, 0);
ret = add_bin_service_record (device, &rec);
sdp_list_free (root, NULL);
sdp_list_free (svclass_id, NULL);
sdp_list_free (pfseq, NULL);
sdp_list_free (apseq, NULL);
sdp_list_free (aproto, NULL);
sdp_list_free (proto[0], NULL);
sdp_list_free (proto[1], NULL);
sdp_list_free (proto[2], NULL);
sdp_data_free (channel);
sdp_list_free (rec.attrlist, (sdp_free_func_t) sdp_data_free);
sdp_list_free (rec.pattern, free);
return ret;
}
void
ods_bluez_remove_service_record (const gchar *device, guint32 record_handle)
{
sdp_session_t *session;
bdaddr_t src;
gint ret;
str2ba (device, &src);
session = sdp_session_get (device, FALSE);
if (!session) {
g_warning ("Couldn't get SDP session");
return;
}
ret = sdp_device_record_unregister_binary (session, &src, record_handle);
if (ret)
g_warning ("Failed to unregister service record");
else
g_message ("SDP service unregistered");
sdp_session_list_remove (device);
}
void
ods_bluez_finalize ()
{
if (sdp_session_list) {
g_hash_table_unref (sdp_session_list);
sdp_session_list = NULL;
}
}
obex-data-server-0.4.6/src/ods-server.h 0000644 0001750 0001750 00000006571 11524724173 014662 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_SERVER_H
#define __ODS_SERVER_H
#include
#include
G_BEGIN_DECLS
#define ODS_SERVER_DBUS_PATH_PATTERN "/org/openobex/server%d"
#define ODS_SERVER_DBUS_INTERFACE "org.openobex.Server"
#define ODS_TYPE_SERVER (ods_server_get_type ())
#define ODS_SERVER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ODS_TYPE_SERVER, OdsServer))
#define ODS_SERVER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), ODS_TYPE_SERVER, OdsServerClass))
#define ODS_IS_SERVER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ODS_TYPE_SERVER))
#define ODS_IS_SERVER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ODS_TYPE_SERVER))
#define ODS_SERVER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ODS_TYPE_SERVER, OdsServerClass))
enum {
ODS_SERVER_FD = 1,
ODS_SERVER_SERVICE,
ODS_SERVER_OWNER,
ODS_SERVER_DBUS_PATH,
ODS_SERVER_PATH,
ODS_SERVER_TTY_DEV
};
typedef struct OdsServerPrivate OdsServerPrivate;
typedef struct
{
GObject parent;
OdsServerPrivate *priv;
} OdsServer;
typedef struct
{
GObjectClass parent_class;
void (* started) (OdsServer *server);
void (* stopped) (OdsServer *server);
void (* closed) (OdsServer *server);
void (* session_created) (OdsServer *server,
const gchar *session_object);
void (* session_removed) (OdsServer *server,
const gchar *session_object);
void (* error_occurred) (OdsServer *server,
const gchar *error_name,
const gchar *error_message);
void (* disposed) (OdsServer *server);
DBusGConnection *connection;
} OdsServerClass;
GType ods_server_get_type (void);
OdsServer *ods_server_new (gint fd,
gint service,
const gchar *owner);
gboolean ods_server_start (OdsServer *server,
const gchar *path,
gboolean allow_write,
gboolean auto_accept,
DBusGMethodInvocation *context);
gboolean ods_server_stop (OdsServer *server,
DBusGMethodInvocation *context);
gboolean ods_server_close (OdsServer *server,
DBusGMethodInvocation *context);
void ods_server_dispose (OdsServer *server);
gboolean ods_server_is_started (OdsServer *server);
gboolean ods_server_set_option (OdsServer *server,
const gchar *name,
GValue *value,
DBusGMethodInvocation *context);
GHashTable *ods_server_get_server_session_info (OdsServer *server, gchar *session_object);
gchar **ods_server_get_server_session_list (OdsServer *server);
G_END_DECLS
#endif /* __ODS_SERVER_H */
obex-data-server-0.4.6/src/ods-logging.h 0000644 0001750 0001750 00000002255 11524724173 014775 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_LOGGING_H_
#define __ODS_LOGGING_H_
#include
void ods_log_init (const char *ident, gboolean enable_syslog, gboolean enable_debug);
void ods_log_finalize ();
void ods_log_obex (const char *prefix, int evt, int cmd, int rsp);
#endif /*__ODS_LOGGING_H_*/
obex-data-server-0.4.6/src/ods-common.h 0000644 0001750 0001750 00000007136 11524724173 014642 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_COMMON_H_
#define __ODS_COMMON_H_
#include
#include
/* Reference to the type of BUS we are using */
extern DBusBusType ODS_DBUS_BUS;
#define ODS_DBUS_SERVICE "org.openobex"
/* ods API version (every incompatible version increases this number) */
#define ODS_API_VERSION 1
#define EOL_CHARS "\n"
enum {
ODS_SERVICE_GOEP = 1,
ODS_SERVICE_OPP,
ODS_SERVICE_FTP,
ODS_SERVICE_PBAP,
ODS_SERVICE_BIP
};
/** Standard folder browsing service UUID */
#define OBEX_FTP_UUID \
"\xF9\xEC\x7B\xC4\x95\x3C\x11\xD2\x98\x4E\x52\x54\x00\xDC\x9E\x09"
/** Nokia OBEX PC Suite Services (used instead of standard FTP for some devices) */
#define OBEX_NOKIAFTP_UUID \
"\x00\x00\x50\x05\x00\x00\x10\x00\x80\x00\x00\x02\xEE\x00\x00\x01"
/** Phone Book Access Profile UUID */
#define OBEX_PBAP_UUID \
"\x79\x61\x35\xF0\xF0\xC5\x11\xD8\x09\x66\x08\x00\x20\x0C\x9A\x66"
/** Basic Imaging Image Push */
#define OBEX_BIP_IPUSH_UUID \
"\xE3\x3D\x95\x45\x83\x74\x4A\xD7\x9E\xC5\xC1\x6B\xE3\x1E\xDE\x8E"
/** Basic Imaging Image Pull */
#define OBEX_BIP_IPULL_UUID \
"\x8E\xE9\xB3\xD0\x46\x08\x11\xD5\x84\x1A\x00\x02\xA5\x32\x5B\x4E"
/** Basic Imaging Advanced Image Printing */
#define OBEX_BIP_AIP_UUID \
"\x92\x35\x33\x50\x46\x08\x11\xD5\x84\x1A\x00\x02\xA5\x32\x5B\x4E"
/** Basic Imaging Automatic Archive */
#define OBEX_BIP_AA_UUID \
"\x94\x01\x26\xC0\x46\x08\x11\xD5\x84\x1A\x00\x02\xA5\x32\x5B\x4E"
/** Basic Imaging Remote Camera */
#define OBEX_BIP_RC_UUID \
"\x94\x7E\x74\x20\x46\x08\x11\xD5\x84\x1A\x00\x02\xA5\x32\x5B\x4E"
/** Basic Imaging Remote Display */
#define OBEX_BIP_RD_UUID \
"\x94\xC7\xCD\x20\x46\x08\x11\xD5\x84\x1A\x00\x02\xA5\x32\x5B\x4E"
/** Basic Imaging Referenced Objects */
#define OBEX_BIP_RO_UUID \
"\x8E\x61\xF9\x5D\x1A\x79\x11\xD4\x8E\xA4\x00\x80\x5F\x9B\x98\x34"
/** Basic Imaging Archived Objects */
#define OBEX_BIP_AO_UUID \
"\x8E\x61\xF9\x5E\x1A\x79\x11\xD4\x8E\xA4\x00\x80\x5F\x9B\x98\x34"
/** Length of UUIDs */
#define OBEX_UUID_LEN 16
#define ODS_OPP_RFCOMM_CHANNEL 9
#define ODS_FTP_RFCOMM_CHANNEL 10
#define ODS_BIP_RFCOMM_CHANNEL 11
#define ODS_PBAP_RFCOMM_CHANNEL 15
gboolean ods_check_bluetooth_address (const gchar *str);
gboolean ods_check_caller (DBusGMethodInvocation *context, const gchar *owner);
gsize ods_filename_to_utf16 (gchar **filename_utf16, const gchar *filename);
gchar *ods_filename_from_utf16 (const gchar *filename_utf16, gssize len);
gint ods_make_iso8601 (time_t time, gchar *str, gint len);
time_t ods_parse_iso8601 (const gchar *str, gint len);
GList *ods_hash_table_get_keys(GHashTable *table);
gchar **ods_hash_table_keys2strv (GHashTable *list);
gboolean ods_safe_gsource_remove (guint *tag);
#endif /*__ODS_COMMON_H_*/
obex-data-server-0.4.6/src/ods-capabilities.h 0000644 0001750 0001750 00000002145 11524724173 015776 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_CAPABILITIES_H_
#define __ODS_CAPABILITIES_H_
#include
gchar* ods_get_capability (const gchar *root_path);
gchar* ods_get_imaging_capabilities ();
#endif /*__ODS_CAPABILITIES_H_*/
obex-data-server-0.4.6/src/ods-common.c 0000644 0001750 0001750 00000014614 11524724173 014634 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include "ods-common.h"
#include "ods-error.h"
/* There shouldn't been a need to init this global variable, but let's do it
* just in case */
DBusBusType ODS_DBUS_BUS=DBUS_BUS_SESSION;
gboolean
ods_check_caller (DBusGMethodInvocation *context, const gchar *owner)
{
gchar *caller;
GError *error = NULL;
gboolean ret = FALSE;
/* check if caller matches owner of some object */
caller = dbus_g_method_get_sender (context);
if (strcmp (caller, owner)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_AUTHORIZED,
"Not authorized");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
goto out;
}
ret = TRUE;
out:
g_free (caller);
return ret;
}
gsize
ods_filename_to_utf16 (gchar **filename_utf16, const gchar *filename)
{
gsize utf16_len;
gchar *filename_utf8;
GError *error = NULL;
if (*filename == '\0') {
*filename_utf16 = "";
return 0;
}
/* convert local filename to utf8 */
filename_utf8 = g_filename_to_utf8 (filename, -1, NULL, NULL, &error);
if (filename_utf8 == NULL) {
g_message ("ods_filename_to_utf16 error: %s", error->message);
g_error_free (error);
*filename_utf16 = NULL;
return 0;
}
/* convert utf8 to utf16 (big endian) */
*filename_utf16 = g_convert (filename_utf8, -1, "UTF16BE", "UTF8", NULL, &utf16_len, &error);
if (*filename_utf16 == NULL) {
g_message ("ods_filename_to_utf16 error: %s", error->message);
g_error_free (error);
utf16_len = 0;
}
g_free (filename_utf8);
(*filename_utf16)[utf16_len+1] = '\0';/* set trailing 0 */
return utf16_len+2;/* utf16_len does not include trailing 0 */
}
gchar *
ods_filename_from_utf16 (const gchar *filename_utf16, gssize len)
{
GError *error = NULL;
gchar *filename_utf8;
gchar *filename;
/* convert utf16 (big endian) to utf8 */
filename_utf8 = g_convert (filename_utf16, len, "UTF8", "UTF16BE", NULL, NULL, &error);
if (filename_utf8 == NULL) {
g_message ("ods_filename_from_utf16 error: %s", error->message);
g_error_free (error);
return NULL;
}
/* convert to local filename */
filename = g_filename_from_utf8 (filename_utf8, -1, NULL, NULL, &error);
if (filename == NULL) {
g_message ("ods_filename_from_utf16 error: %s", error->message);
g_error_free (error);
}
g_free (filename_utf8);
return filename;
}
gint
ods_make_iso8601 (time_t time, gchar *str, gint len)
{
struct tm tm;
#if defined(HAVE_TIMEZONE) && defined(USE_LOCALTIME)
time_t tz_offset = 0;
tz_offset = -timezone;
if (daylight > 0)
tz_offset += 3600;
time += tz_offset;
#endif
if (gmtime_r(&time, &tm) == NULL)
return -1;
tm.tm_year += 1900;
tm.tm_mon++;
return snprintf(str, len,
#ifdef USE_LOCALTIME
"%04u%02u%02uT%02u%02u%02u",
#else
"%04u%02u%02uT%02u%02u%02uZ",
#endif
tm.tm_year, tm.tm_mon, tm.tm_mday,
tm.tm_hour, tm.tm_min, tm.tm_sec);
}
/* From Imendio's GnomeVFS OBEX module (om-utils.c) */
time_t
ods_parse_iso8601 (const gchar *str, gint len)
{
gchar *tstr;
struct tm tm;
gint nr;
gchar tz;
time_t time;
time_t tz_offset = 0;
memset (&tm, 0, sizeof (struct tm));
/* According to spec the time doesn't have to be null terminated */
if (str[len - 1] != '\0') {
tstr = g_malloc(len + 1);
strncpy(tstr, str, len);
tstr[len] = '\0';
} else {
tstr = g_strdup(str);
}
nr = sscanf (tstr, "%04u%02u%02uT%02u%02u%02u%c",
&tm.tm_year, &tm.tm_mon, &tm.tm_mday,
&tm.tm_hour, &tm.tm_min, &tm.tm_sec,
&tz);
g_free(tstr);
/* Fixup the tm values */
tm.tm_year -= 1900; /* Year since 1900 */
tm.tm_mon--; /* Months since January, values 0-11 */
tm.tm_isdst = -1; /* Daylight savings information not avail */
if (nr < 6) {
/* Invalid time format */
return -1;
}
time = mktime (&tm);
#if defined(HAVE_TM_GMTOFF)
tz_offset = tm.tm_gmtoff;
#elif defined(HAVE_TIMEZONE)
tz_offset = -timezone;
if (tm.tm_isdst > 0) {
tz_offset += 3600;
}
#endif
if (nr == 7) { /* Date/Time was in localtime (to remote device)
* already. Since we don't know anything about the
* timezone on that one we won't try to apply UTC offset
*/
time += tz_offset;
}
return time;
}
static void
prepend_key_to_list(gpointer key, gpointer value, GList **list_keys)
{
*list_keys = g_list_prepend (*list_keys, key);
}
/* Implemented for better portability */
GList *
ods_hash_table_get_keys(GHashTable *table)
{
GList *list_keys = NULL;
g_hash_table_foreach (table, (GHFunc) prepend_key_to_list, &list_keys);
return list_keys;
}
gchar**
ods_hash_table_keys2strv (GHashTable *list)
{
guint list_size, i = 0;
GHashTableIter iter;
gpointer key, value;
gchar **list_keys = NULL;
list_size = g_hash_table_size (list);
if (list_size) {
list_keys = malloc (sizeof(gchar*) * (list_size+1));
g_hash_table_iter_init (&iter, list);
while (g_hash_table_iter_next (&iter, &key, &value)) {
list_keys[i] = g_strdup (key);
i++;
}
list_keys[i] = NULL;
}
return list_keys;
}
/* safely removes event source
* (checks if source exists before calling g_source_remove
* and resets tag value) */
gboolean
ods_safe_gsource_remove (guint *tag)
{
GSource* source;
gboolean ret = FALSE;
if (!*tag)
return FALSE;
source = g_main_context_find_source_by_id (g_main_context_default(), *tag);
if (source) {
ret = g_source_remove (*tag);
*tag = 0;
}
return ret;
}
obex-data-server-0.4.6/src/ods-server-session.c 0000644 0001750 0001750 00000120166 11524724173 016333 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-common.h"
#include "ods-error.h"
#include "ods-marshal.h"
#include "ods-logging.h"
#include "ods-obex.h"
#include "ods-server-session.h"
#include "ods-server-session-dbus-glue.h"
static void ods_server_session_finalize (GObject *object);
#define ODS_SERVER_SESSION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ODS_TYPE_SERVER_SESSION, OdsServerSessionPrivate))
#define ODS_SERVER_SESSION_LOCK(server_session) g_message ("LOCK %s", __FUNCTION__); g_static_mutex_lock (&(server_session)->priv->mutex)
#define ODS_SERVER_SESSION_UNLOCK(server_session) g_message ("UNLOCK %s", __FUNCTION__); g_static_mutex_unlock (&(server_session)->priv->mutex)
#define ODS_SERVER_SESSION_DBUS_PATH_PATTERN "/org/openobex/serversession%d"
#define ODS_SERVER_SESSION_DBUS_INTERFACE "org.openobex.ServerSession"
typedef enum {
ODS_SERVER_SESSION_STATE_NOT_CONNECTED,
ODS_SERVER_SESSION_STATE_OPEN,
ODS_SERVER_SESSION_STATE_BUSY
} OdsServerSessionState;
struct OdsServerSessionPrivate {
/* constructor properties */
gint fd; /* rfcomm device */
guint service;
gchar *root_path; /* root folder (constructor "path" property) */
gchar *path; /* current path */
gchar *owner; /* D-Bus client, who initiated this session */
gboolean allow_write; /* Whether to allow changes in file system */
gboolean auto_accept; /* Whether incoming files should be auto-accepted */
gboolean require_imaging_thumbnails;/* whether to request thumbnail after PutImage is completed */
/* other properties */
gboolean using_tty;/* if we are using tty device */
/* state (open or busy) */
OdsServerSessionState state; /* ODS_SERVER_SESSION_STATE_OPEN by default */
/* OBEX connection */
OdsObexContext *obex_context;
/* other */
GStaticMutex mutex;
DBusGMethodInvocation *dbus_context; /* D-Bus context for async methods */
gchar *dbus_path; /* D-Bus path for this object */
/* BIP-specific */
GHashTable *img_handle_list;/* hash list associating image handles with real filenames */
guint selected_img;/* selected image handle (for RemoteDisplay functions) */
};
enum {
CANCELLED,
DISCONNECTED,
TRANSFER_STARTED,
TRANSFER_PROGRESS,
TRANSFER_COMPLETED,
ERROR_OCCURRED,
REMOTE_DISPLAY_REQUESTED,
LAST_SIGNAL
};
static guint signals [LAST_SIGNAL] = { 0, };
/* for numbering established sessions */
static guint iterator = 0;
G_DEFINE_TYPE (OdsServerSession, ods_server_session, G_TYPE_OBJECT)
/* This is to be called from mainloop, not directly. It's to ensure
* that we don't finalize this object from within itself. */
static gboolean
emit_disconnected (OdsServerSession *server_session)
{
ods_obex_close_transport (server_session->priv->obex_context);
g_signal_emit (server_session, signals [DISCONNECTED], 0);
return FALSE;
}
/* adds uploaded image to list and returns it's image handle */
static const gchar*
image_list_add (OdsServerSession *server_session, const gchar *filename)
{
gchar *img_handle;
if (!server_session->priv->img_handle_list) {
server_session->priv->img_handle_list = g_hash_table_new_full (
g_str_hash, g_str_equal,
g_free, g_free);
}
img_handle = g_strdup_printf ("%07u",
g_hash_table_size (server_session->priv->img_handle_list)+1);
g_hash_table_insert (server_session->priv->img_handle_list, img_handle,
g_strdup (filename));
return img_handle;
}
static void
remote_display_action (OdsServerSession *server_session, guint8 action)
{
OdsServerSessionPrivate *priv;
gchar *img_handle = NULL;
gchar *filename;
priv = server_session->priv;
if (action == 0)
return;
switch (action) {
case BIP_REMOTEDISPLAY_NEXTIMAGE:
if (priv->selected_img < g_hash_table_size (priv->img_handle_list))
priv->selected_img++;
break;
case BIP_REMOTEDISPLAY_PREVIOUSIMAGE:
if (priv->selected_img > 1)
priv->selected_img--;
break;
case BIP_REMOTEDISPLAY_SELECTIMAGE:
priv->selected_img = atoi (priv->obex_context->img_handle);
if (priv->selected_img > g_hash_table_size (priv->img_handle_list) ||
priv->selected_img < 1) {
/* resort to first */
priv->selected_img = 1;
} else {
/* valid value, use this img_handle */
img_handle = g_strdup (priv->obex_context->img_handle);
}
break;
case BIP_REMOTEDISPLAY_CURRENTIMAGE:
break;
default:
g_message ("Invalid RemoteDisplay action specified");
return;
}
if (!img_handle) {
/* get img_handle from selected_img */
img_handle = g_strdup_printf ("%07u", priv->selected_img);
}
/* lookup filename for selected img_handle */
if (!(filename = g_hash_table_lookup (priv->img_handle_list, img_handle))) {
/* should never happen since we did all bounds checking */
g_warning ("Selected img_handle not found in img_handle_list");
return;
}
/* finally emit RemoteDisplayRequested */
g_signal_emit (server_session, signals [REMOTE_DISPLAY_REQUESTED], 0,
filename);
g_free (img_handle);
}
static gboolean
obex_io_callback (GIOChannel *io_channel, GIOCondition cond, gpointer data)
{
obex_t *obex_handle;
OdsServerSession *server_session;
GError *error = NULL;
gboolean ret = TRUE;
obex_handle = (obex_t *) data;
server_session = ODS_SERVER_SESSION (OBEX_GetUserData (obex_handle));
g_message ("io callback");
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_LINK_ERROR, "Connection error");
/* cleanup transfer data */
ods_obex_transfer_close (server_session->priv->obex_context);
server_session->priv->state = ODS_SERVER_SESSION_STATE_NOT_CONNECTED;
ret = FALSE;
} else if (OBEX_HandleInput (obex_handle, 1) < 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_BAD_DATA,
"Could not parse incoming data");
}
if (error) {
gchar *error_name;
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred signal */
g_signal_emit (server_session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
}
if (!ret) {
/* Also emit DISCONNECTED signal, since this session is now defunct */
g_idle_add ((GSourceFunc) emit_disconnected, server_session);
}
return ret;
}
static void
obex_transfer_data_exchange_done (OdsServerSession *server_session, gint ret)
{
GError *error = NULL;
gchar *error_name;
OdsObexContext *obex_context;
obex_context = server_session->priv->obex_context;
if (ret < 0) {
ods_error_err2gerror (ret, &error);
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred Signal */
g_signal_emit (server_session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
/* Reset state */
server_session->priv->state = ODS_SERVER_SESSION_STATE_OPEN;
} else if (ret == 0 && !obex_context->transfer_started_signal_emitted &&
obex_context->report_progress && obex_context->local) {
g_signal_emit (server_session, signals [TRANSFER_STARTED], 0,
obex_context->remote,
obex_context->local,
obex_context->target_size);
obex_context->transfer_started_signal_emitted = TRUE;
g_message ("TransferStarted emitted at obex_transfer_data_exchange_done");
}
}
static void
send_image_handle (OdsServerSession *server_session, OdsObexContext *obex_context,
obex_object_t *object)
{
/* In the end of BIP PutImage request ImageHandle has to be sent
* Make sure that we have transfer info (PUT request was received).
* This might be called on last readstream but REQCHECK event
* might not have happened yet (happens with small files). */
const gchar *img_handle;
gchar *uhandle = NULL;
gsize uhandle_len = 0;
obex_headerdata_t hv;
gint ret;
if (server_session->priv->service == ODS_SERVICE_BIP &&
obex_context->obex_cmd == OBEX_CMD_PUT && obex_context->local &&
!g_ascii_strncasecmp (obex_context->type, BIP_IMG_TYPE,
strlen (obex_context->type))) {
img_handle = image_list_add (server_session, obex_context->local);
uhandle_len = ods_filename_to_utf16 (&uhandle, img_handle);
if (uhandle == NULL) {
g_warning ("Failed to convert img_handle");
return;
}
hv.bs = (guchar *)uhandle;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_IMG_HANDLE, hv,
uhandle_len, 0);
g_free (uhandle);
if (ret < 0) {
g_warning ("Failed to add header");
return;
}
if (server_session->priv->require_imaging_thumbnails)
OBEX_ObjectSetRsp (object, OBEX_RSP_PARTIAL_CONTENT, OBEX_RSP_PARTIAL_CONTENT);
else
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
}
}
static void
obex_request_cancelled (OdsServerSession *server_session, OdsObexContext *obex_context)
{
/* Cleanup transfer stuff and reset state */
/* If it was PUT operation, remove incomplete file */
if (obex_context->obex_cmd == OBEX_CMD_PUT &&
obex_context->stream_fd >= 0)
g_unlink (obex_context->local);
ods_obex_transfer_close (obex_context);
server_session->priv->state = ODS_SERVER_SESSION_STATE_OPEN;
/* emit CANCELLED signal */
g_signal_emit (server_session, signals [CANCELLED], 0);
/* In case this was trigerred by Cancel method */
if (server_session->priv->dbus_context) {
dbus_g_method_return (server_session->priv->dbus_context);
server_session->priv->dbus_context = NULL;
ODS_SERVER_SESSION_UNLOCK (server_session);
}
}
static gint
obex_suspend_request (OdsServerSession *server_session, OdsObexContext *obex_context)
{
/* only suspend if TransferStarted signal was already emitted */
if (!server_session->priv->auto_accept &&
obex_context->transfer_started_signal_emitted &&
!obex_context->suspend_result) {
ods_obex_transfer_suspend (obex_context);
if (obex_context->suspend_result == OBEX_SUSP_REJECTED)
ods_server_session_cancel_internal (server_session);
return obex_context->suspend_result;
}
return 0;
}
static void
obex_request_put (OdsServerSession *server_session, OdsObexContext *obex_context,
obex_object_t *object)
{
guint8 action = 0;/* only used for BIP RemoteDisplay*/
gint ret, suspend_ret;
gboolean no_response_on_success = FALSE;
gchar *img_filename;
/* Check if we already have all transfer info
* because both EV_REQCHECK and EV_REQ trigger this function */
if (obex_context->stream_fd >= 0)
return;
if (!server_session->priv->allow_write) {
g_message ("CMD_PUT forbidden");
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN,
OBEX_RSP_FORBIDDEN);
return;
}
/* Check if we have write permissions for current path */
if (g_access (server_session->priv->path, W_OK) < 0) {
g_message ("No write permissions for current path");
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED,
OBEX_RSP_UNAUTHORIZED);
return;
}
/* If auto_accept is False and transfer hasn't been suspended yet,
* we will not send response until the transfer is accepted or rejected */
if (!server_session->priv->auto_accept && !obex_context->suspend_result)
no_response_on_success = TRUE;
ret = ods_obex_srv_put (obex_context, object,
server_session->priv->path, &action, no_response_on_success);
g_message ("ret=%d", ret);
/* Add ImageFilename to ExtInfo according to ImageHandle (for BIP) */
if (ret == 0 && obex_context->img_handle) {
img_filename = g_hash_table_lookup (server_session->priv->img_handle_list,
obex_context->img_handle);
if (!img_filename)
g_message ("Invalid ImgHandle received");
else
ods_obex_transfer_add_info (obex_context, "ImageFilename",
g_strdup (img_filename));
}
/* Process BIP RemoteDisplay info (if available) */
if (ret == 0)
remote_display_action (server_session, action);
/* also emit TransferStarted signal */
if (ret == 0 && !obex_context->transfer_started_signal_emitted &&
obex_context->report_progress && obex_context->local) {
g_signal_emit (server_session, signals [TRANSFER_STARTED],
0, obex_context->remote,
obex_context->local,
obex_context->target_size);
obex_context->transfer_started_signal_emitted = TRUE;
g_message ("TransferStarted emitted at obex_request_put");
}
/* In a rare situation when received file is smaller than MTU,
* this function is called after all data is already received.
* We have to suspend request if auto_accept is False;
* For BIP, image handle has to be sent as well */
if (ret == 0) {
suspend_ret = obex_suspend_request (server_session, obex_context);
if (suspend_ret == OBEX_SUSP_REJECTED) {
/* Transfer was rejected and no more data will be received so we
* delete written file, emit Cancelled signal and send RSP_FORBIDDEN */
obex_request_cancelled (server_session, obex_context);
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
} else if (suspend_ret == OBEX_SUSP_ACCEPTED) {
/* Transfer was accepted, send RSP_SUCCESS */
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
}
if (suspend_ret != OBEX_SUSP_REJECTED) {
/* Transfer was accepted either now or earlier */
send_image_handle (server_session, obex_context, object);
}
}
}
static void
obex_event (obex_t *handle, obex_object_t *object, int mode, int event,
int command, int response)
{
OdsServerSession *server_session;
OdsObexContext *obex_context;
gchar *new_path;
gint ret;
server_session = ODS_SERVER_SESSION (OBEX_GetUserData (handle));
obex_context = server_session->priv->obex_context;
ods_log_obex (server_session->priv->dbus_path, event, command, response);
switch (event) {
case OBEX_EV_PROGRESS:
if (obex_context->report_progress) {
g_signal_emit (server_session, signals [TRANSFER_PROGRESS], 0,
obex_context->counter);
}
break;
case OBEX_EV_LINKERR:
/* we will get LINKERR when Cancel was called, but device didn't
* send OBEX_RSP_SUCCESS response (might be OBEX_RSP_BAD_REQUEST).
* When link error really happens, it is handled in io_callback */
g_warning ("EV_LINKERR");
case OBEX_EV_ABORT:
obex_request_cancelled (server_session, obex_context);
break;
case OBEX_EV_REQDONE:
switch (command) {
case OBEX_CMD_DISCONNECT:
ods_server_session_disconnect_internal (server_session);
break;
case OBEX_CMD_PUT:
/* Transfer complete */
ods_obex_transfer_close (obex_context);
server_session->priv->state = ODS_SERVER_SESSION_STATE_OPEN;
if (obex_context->report_progress)
g_signal_emit (server_session, signals [TRANSFER_COMPLETED], 0);
break;
case OBEX_CMD_GET:
/* Transfer complete */
ods_obex_transfer_close (obex_context);
server_session->priv->state = ODS_SERVER_SESSION_STATE_OPEN;
if (obex_context->report_progress)
g_signal_emit (server_session, signals [TRANSFER_COMPLETED], 0);
break;
default:
break;
}
break;
case OBEX_EV_REQHINT:
switch (command) {
case OBEX_CMD_PUT:
OBEX_ObjectReadStream (handle, object, NULL);
obex_context->obex_cmd = OBEX_CMD_PUT;
/* Initialize transfer and set state */
ods_obex_transfer_new (obex_context, NULL, NULL, NULL);
server_session->priv->state = ODS_SERVER_SESSION_STATE_BUSY;
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE,
OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_GET:
obex_context->obex_cmd = OBEX_CMD_GET;
/* Initialize transfer and set state */
ods_obex_transfer_new (obex_context, NULL, NULL, NULL);
server_session->priv->state = ODS_SERVER_SESSION_STATE_BUSY;
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE,
OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_CONNECT:
case OBEX_CMD_DISCONNECT:
case OBEX_CMD_SETPATH:
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE,
OBEX_RSP_SUCCESS);
break;
default:
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
OBEX_RSP_NOT_IMPLEMENTED);
break;
}
break;
case OBEX_EV_REQCHECK:
if (command == OBEX_CMD_PUT) {
g_message ("CMD_PUT requested at REQCHECK");
obex_request_put (server_session, obex_context, object);
}
break;
case OBEX_EV_REQ:
switch (command) {
case OBEX_CMD_DISCONNECT:
OBEX_ObjectSetRsp(object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
break;
case OBEX_CMD_CONNECT:
g_message ("CMD_CONNECT requested");
ods_obex_srv_connect (obex_context, object, server_session->priv->service);
break;
case OBEX_CMD_SETPATH:
if (server_session->priv->service == ODS_SERVICE_OPP) {
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
OBEX_RSP_NOT_IMPLEMENTED);
return;
}
g_message ("CMD_SETPATH requested");
g_message ("current path: %s", server_session->priv->path);
g_message ("root path: %s", server_session->priv->root_path);
if (ods_obex_srv_setpath (obex_context, object,
server_session->priv->root_path,
server_session->priv->path,
&new_path,
server_session->priv->allow_write)) {
g_free (server_session->priv->path);
server_session->priv->path = new_path;
}
g_message ("new path: %s", server_session->priv->path);
break;
case OBEX_CMD_GET:
g_message ("CMD_GET requested");
ret = ods_obex_srv_get (obex_context, object,
server_session->priv->path,
server_session->priv->root_path,
server_session->priv->allow_write);
g_message ("ret=%d", ret);
if (ret > 0 && obex_context->report_progress) {
g_signal_emit (server_session, signals [TRANSFER_STARTED],
0, obex_context->remote,
obex_context->local,
obex_context->target_size);
obex_context->transfer_started_signal_emitted = TRUE;
g_message ("TransferStarted emitted at obex_event at OBEX_EV_REQ");
}
break;
case OBEX_CMD_PUT:
g_message ("CMD_PUT requested");
obex_request_put (server_session, obex_context, object);
break;
default:
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED,
OBEX_RSP_NOT_IMPLEMENTED);
break;
}
break;
case OBEX_EV_STREAMEMPTY:
ret = ods_obex_writestream (obex_context, object);
obex_transfer_data_exchange_done (server_session, ret);
break;
case OBEX_EV_STREAMAVAIL:
ret = 0;
if (!server_session->priv->allow_write) {
g_message ("CMD_PUT forbidden");
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN,
OBEX_RSP_FORBIDDEN);
/* We don't emit ErrorOccurred for this situation */
return;
}
/* Check if we have write permissions for current path */
if (g_access (server_session->priv->path, W_OK) < 0) {
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED,
OBEX_RSP_UNAUTHORIZED);
ret = -EACCES;
goto readstream_done;
}
/* This PUT request is definitely not a delete request. Let's
* open a file for writing in case this wasn't done yet */
if (obex_context->remote && !obex_context->local) {
if (!ods_obex_srv_new_file (obex_context, server_session->priv->path)) {
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED,
OBEX_RSP_UNAUTHORIZED);
ret = -EACCES;
goto readstream_done;
}
}
/* suspend request if necessary */
obex_suspend_request (server_session, obex_context);
ret = ods_obex_readstream (obex_context, object);
readstream_done:
obex_transfer_data_exchange_done (server_session, ret);
if (ret == 2) {
/* Transfer was cancelled by sending RSP_FORBIDDEN, this will
* not trigger EV_ABORT so we need to emit Cancelled signal here */
obex_request_cancelled (server_session, obex_context);
} else if (ret == 1) {
/* Last packet was received, send image handle */
send_image_handle (server_session, obex_context, object);
}
break;
case OBEX_EV_PARSEERR:
/* Handled in io_callback */
break;
case OBEX_EV_UNEXPECTED:
break;
default:
break;
}
}
static void
ods_server_session_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
OdsServerSession *self = ODS_SERVER_SESSION (object);
switch (property_id) {
case ODS_SERVER_SESSION_FD:
self->priv->fd = g_value_get_int (value);
if (self->priv->fd >= 0) {
OdsObexContext *obex_context = self->priv->obex_context;
GError *error = NULL;
guint16 rx_mtu = ODS_DEFAULT_RX_MTU;
guint16 tx_mtu = ODS_DEFAULT_TX_MTU;
g_message ("Creating server session");
if (self->priv->using_tty) {
rx_mtu = ODS_TTY_RX_MTU;
tx_mtu = ODS_TTY_TX_MTU;
}
ods_obex_setup_fdtransport (obex_context,
self->priv->fd, rx_mtu, tx_mtu,
obex_event, obex_io_callback,
self, &error);
if (error) {
g_warning ("Error while creating server session: %s",
error->message);
ods_server_session_disconnect_internal (self);
g_clear_error (&error);
}
}
break;
case ODS_SERVER_SESSION_SERVICE:
self->priv->service = g_value_get_int (value);
break;
case ODS_SERVER_SESSION_PATH:
self->priv->root_path = g_value_dup_string (value);
self->priv->path = g_value_dup_string (value);
g_warning ("Session path: %s", self->priv->path);
break;
case ODS_SERVER_SESSION_ALLOW_WRITE:
self->priv->allow_write = g_value_get_boolean (value);
break;
case ODS_SERVER_SESSION_AUTO_ACCEPT:
self->priv->auto_accept = g_value_get_boolean (value);
break;
case ODS_SERVER_SESSION_REQUIRE_IMAGING_THUMBNAILS:
self->priv->require_imaging_thumbnails = g_value_get_boolean (value);
break;
case ODS_SERVER_SESSION_USING_TTY:
self->priv->using_tty = g_value_get_boolean (value);
break;
case ODS_SERVER_SESSION_OWNER:
self->priv->owner = g_value_dup_string (value);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
break;
}
}
static void
ods_server_session_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
OdsServerSession *self = ODS_SERVER_SESSION (object);
switch (property_id) {
case ODS_SERVER_SESSION_FD:
g_value_set_int (value, self->priv->fd);
break;
case ODS_SERVER_SESSION_SERVICE:
g_value_set_int (value, self->priv->service);
break;
case ODS_SERVER_SESSION_PATH:
g_value_set_string (value, self->priv->path);
break;
case ODS_SERVER_SESSION_ALLOW_WRITE:
g_value_set_boolean (value, self->priv->allow_write);
break;
case ODS_SERVER_SESSION_AUTO_ACCEPT:
g_value_set_boolean (value, self->priv->auto_accept);
break;
case ODS_SERVER_SESSION_REQUIRE_IMAGING_THUMBNAILS:
g_value_set_boolean (value, self->priv->require_imaging_thumbnails);
break;
case ODS_SERVER_SESSION_USING_TTY:
g_value_set_boolean (value, self->priv->using_tty);
break;
case ODS_SERVER_SESSION_OWNER:
g_value_set_string (value, self->priv->owner);
break;
case ODS_SERVER_SESSION_DBUS_PATH:
g_value_set_string (value, self->priv->dbus_path);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
break;
}
}
/**
* ods_server_session_class_init:
* @klass: The OdsServerSessionClass
**/
static void
ods_server_session_class_init (OdsServerSessionClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = ods_server_session_finalize;
object_class->set_property = ods_server_session_set_property;
object_class->get_property = ods_server_session_get_property;
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_FD,
g_param_spec_int ("fd",
"", "",
-1, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_SERVICE,
g_param_spec_int ("service",
"", "",
0, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_PATH,
g_param_spec_string ("path",
"", "",
"" /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_OWNER,
g_param_spec_string ("owner",
"", "",
"" /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_ALLOW_WRITE,
g_param_spec_boolean("allow-write",
"", "",
FALSE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_AUTO_ACCEPT,
g_param_spec_boolean("auto-accept",
"", "",
TRUE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_REQUIRE_IMAGING_THUMBNAILS,
g_param_spec_boolean("require-imaging-thumbnails",
"", "",
FALSE,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_USING_TTY,
g_param_spec_boolean("using-tty",
"", "",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SERVER_SESSION_DBUS_PATH,
g_param_spec_string ("dbus-path",
"", "",
"" /* default value */,
G_PARAM_READABLE));
signals [CANCELLED] =
g_signal_new ("cancelled",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, cancelled),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [DISCONNECTED] =
g_signal_new ("disconnected",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, disconnected),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [TRANSFER_STARTED] =
g_signal_new ("transfer-started",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, transfer_started),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING_UINT64,
G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64);
signals [TRANSFER_PROGRESS] =
g_signal_new ("transfer-progress",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, transfer_progress),
NULL,
NULL,
ods_marshal_VOID__UINT64,
G_TYPE_NONE, 1, G_TYPE_UINT64);
signals [TRANSFER_COMPLETED] =
g_signal_new ("transfer-completed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, transfer_completed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [ERROR_OCCURRED] =
g_signal_new ("error-occurred",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, error_occurred),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
signals [REMOTE_DISPLAY_REQUESTED] =
g_signal_new ("remote-display-requested",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsServerSessionClass, remote_display_requested),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
g_type_class_add_private (klass, sizeof (OdsServerSessionPrivate));
GError *error = NULL;
/* Init the DBus connection, per-klass */
klass->connection = dbus_g_bus_get (ODS_DBUS_BUS, &error);
if (klass->connection == NULL) {
g_warning("Unable to connect to dbus: %s", error->message);
g_clear_error (&error);
return;
}
/* &dbus_glib_ods_server_session_object_info is provided in the
* dbus/ods-server-session-dbus-glue.h file */
dbus_g_object_type_install_info (ODS_TYPE_SERVER_SESSION, &dbus_glib_ods_server_session_object_info);
}
/**
* ods_server_session_init:
* @server_session: This class instance
**/
static void
ods_server_session_init (OdsServerSession *server_session)
{
OdsServerSessionClass *klass = ODS_SERVER_SESSION_GET_CLASS (server_session);
server_session->priv = ODS_SERVER_SESSION_GET_PRIVATE (server_session);
server_session->priv->obex_context = ods_obex_context_new ();
/* figure out DBus object path for this instance */
server_session->priv->state = ODS_SERVER_SESSION_STATE_OPEN;
server_session->priv->dbus_path = g_strdup_printf (ODS_SERVER_SESSION_DBUS_PATH_PATTERN,
iterator);
iterator++;
/* default selected image handle for BIP RemoteDisplay is 0000001 */
server_session->priv->selected_img = 1;
/* create mutex */
g_static_mutex_init (&server_session->priv->mutex);
dbus_g_connection_register_g_object (klass->connection,
server_session->priv->dbus_path,
G_OBJECT (server_session));
}
/**
* ods_server_session_finalize:
* @object: The object to finalize
*
* Finalize the session
**/
static void
ods_server_session_finalize (GObject *object)
{
OdsServerSession *server_session;
g_return_if_fail (object != NULL);
g_return_if_fail (ODS_IS_SERVER_SESSION (object));
server_session = ODS_SERVER_SESSION (object);
g_return_if_fail (server_session->priv != NULL);
/* close connection, free obex_context */
g_message ("closing connection");
/* In TTY mode, fd ownership will revert to the OdsServer, so don't
* close it. See server_session_disconnected_cb. */
if (!server_session->priv->using_tty) {
shutdown (server_session->priv->fd, SHUT_RDWR);
close (server_session->priv->fd);
}
server_session->priv->fd = -1;
OBEX_Cleanup (server_session->priv->obex_context->obex_handle);
g_free (server_session->priv->obex_context);
/* free other private variables */
if (server_session->priv->img_handle_list)
g_hash_table_unref (server_session->priv->img_handle_list);
g_free (server_session->priv->root_path);
g_free (server_session->priv->path);
g_free (server_session->priv->owner);
g_free (server_session->priv->dbus_path);
g_static_mutex_free (&server_session->priv->mutex);
G_OBJECT_CLASS (ods_server_session_parent_class)->finalize (object);
}
/**
* ods_server_session_new:
*
* Return value: a new OdsServerSession object.
**/
OdsServerSession *
ods_server_session_new (gint fd, gint service, const gchar *path,
gboolean allow_write, gboolean auto_accept,
gboolean require_imaging_thumbnails,
const gchar *owner)
{
OdsServerSession *server_session;
server_session = g_object_new (ODS_TYPE_SERVER_SESSION,
"fd", fd,
"service", service,
"path", path,
"allow-write", allow_write,
"auto-accept", auto_accept,
"require-imaging-thumbnails", require_imaging_thumbnails,
"owner", owner,
NULL);
return ODS_SERVER_SESSION (server_session);
}
gboolean
ods_server_session_accept (OdsServerSession *server_session,
DBusGMethodInvocation *context)
{
GError *error = NULL;
ODS_SERVER_SESSION_LOCK (server_session);
/* do checks */
if (!ods_check_caller (context, server_session->priv->owner)) {
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
if (server_session->priv->state != ODS_SERVER_SESSION_STATE_BUSY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"There is no transfer in progress");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
/* Accept file */
server_session->priv->obex_context->suspend_result = OBEX_SUSP_ACCEPTED;
dbus_g_method_return (context);
ODS_SERVER_SESSION_UNLOCK (server_session);
return TRUE;
}
gboolean
ods_server_session_reject (OdsServerSession *server_session,
DBusGMethodInvocation *context)
{
GError *error = NULL;
ODS_SERVER_SESSION_LOCK (server_session);
/* do checks */
if (!ods_check_caller (context, server_session->priv->owner)) {
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
if (server_session->priv->state != ODS_SERVER_SESSION_STATE_BUSY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"There is no transfer in progress");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
/* Reject file */
server_session->priv->obex_context->suspend_result = OBEX_SUSP_REJECTED;
dbus_g_method_return (context);
ODS_SERVER_SESSION_UNLOCK (server_session);
return TRUE;
}
void
ods_server_session_disconnect_internal (OdsServerSession *server_session)
{
if (server_session->priv->state == ODS_SERVER_SESSION_STATE_OPEN) {
OBEX_TransportDisconnect (server_session->priv->obex_context->obex_handle);
server_session->priv->state = ODS_SERVER_SESSION_STATE_NOT_CONNECTED;
}
g_idle_add ((GSourceFunc) emit_disconnected, server_session);
}
gboolean
ods_server_session_disconnect (OdsServerSession *server_session,
DBusGMethodInvocation *context)
{
GError *error = NULL;
ODS_SERVER_SESSION_LOCK (server_session);
/* do checks */
if (!ods_check_caller (context, server_session->priv->owner)) {
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
if (server_session->priv->state == ODS_SERVER_SESSION_STATE_BUSY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_BUSY,
"Operations in progress need to be cancelled first");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
ods_server_session_disconnect_internal (server_session);
dbus_g_method_return (context);
ODS_SERVER_SESSION_UNLOCK (server_session);
return TRUE;
}
GHashTable *
ods_server_session_get_transfer_info (OdsServerSession *server_session)
{
return ods_obex_transfer_get_info (server_session->priv->obex_context);
}
gboolean
ods_server_session_cancel_internal (OdsServerSession *server_session)
{
OdsObexContext *ctxt = server_session->priv->obex_context;
if (server_session->priv->state != ODS_SERVER_SESSION_STATE_BUSY) {
/* emit CANCELLED signal now */
g_signal_emit (server_session, signals[CANCELLED], 0);
return FALSE;
}
if (ctxt->obex_cmd == OBEX_CMD_GET) {
/* Send CMD_ABORT now */
OBEX_CancelRequest (ctxt->obex_handle, TRUE);
} else {
/* Send RSP_FORBIDDEN at obex_readstream;
* cleanup will be done in obex_event */
ctxt->cancelled = TRUE;
}
/* In case ServerSession got stuck in suspended mode (client app quitted without
* accepting/rejecting transfer), we reject transfer at this point */
server_session->priv->obex_context->suspend_result = OBEX_SUSP_REJECTED;
return TRUE;
}
gboolean
ods_server_session_cancel (OdsServerSession *server_session,
DBusGMethodInvocation *context)
{
ODS_SERVER_SESSION_LOCK (server_session);
/* do checks */
if (!ods_check_caller (context, server_session->priv->owner)) {
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
if (ods_server_session_cancel_internal (server_session)) {
if (server_session->priv->dbus_context) {
GError *error;
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SERVER_SESSION_UNLOCK (server_session);
return FALSE;
}
/* set dbus context */
server_session->priv->dbus_context = context;
/* will return at obex_event{EV_ABORT} */
} else {
dbus_g_method_return (context);
ODS_SERVER_SESSION_UNLOCK (server_session);
}
return TRUE;
}
obex-data-server-0.4.6/src/ods-imaging-helpers.h 0000644 0001750 0001750 00000005561 11524724173 016425 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_IMAGING_HELPERS_H_
#define __ODS_IMAGING_HELPERS_H_
#include
enum {
ODS_IMAGING_TRANSFORMATION_STRETCH = 1,
ODS_IMAGING_TRANSFORMATION_CROP,
ODS_IMAGING_TRANSFORMATION_FILL
};
#define ODS_IMAGING_TRANSFORMATION_STRETCH_STR "stretch"
#define ODS_IMAGING_TRANSFORMATION_CROP_STR "crop"
#define ODS_IMAGING_TRANSFORMATION_FILL_STR "fill"
#define ODS_IMAGING_THUMBNAIL_WIDTH 160
#define ODS_IMAGING_THUMBNAIL_HEIGHT 120
#define ODS_IMAGING_THUMBNAIL_ENCODING "JPEG"
typedef struct OdsImageInfo_ {
gchar *filename;
gchar *resized_image_filename;
gulong width;
gulong height;
gchar *encoding;
guint transformation;
goffset size;
} OdsImageInfo;
typedef void (* OdsImagingFunc) (OdsImageInfo*, gpointer);
gchar* get_image_descriptor (const gchar *encoding, const gchar *pixel,
guint64 size, const gchar *transformation);
gchar* get_attachment_descriptor (const gchar *name, guint64 size,
const gchar *content_type, const gchar *charset,
const gchar *created);
void parse_image_descriptor (const gchar *descriptor, gchar **encoding,
gchar **pixel, guint64 *size,
gchar **transformation);
void parse_attachment_descriptor (const gchar *descriptor, gchar **name,
guint64 *size, gchar **content_type,
gchar **charset, gchar **created);
void ods_image_info_free (OdsImageInfo *info);
gchar* ods_imaging_get_pixel_string (gulong width, gulong height);
const gchar* ods_imaging_get_transformation_string (guint transformation);
guint ods_imaging_get_transformation (const gchar *trans);
gboolean ods_imaging_get_image_info_async (const gchar *filename,
OdsImagingFunc func, gpointer data);
gboolean ods_imaging_resize_image_async (const gchar *filename, gulong width,
gulong height, const gchar *encoding, guint transformation,
OdsImagingFunc func, gpointer data);
gboolean ods_imaging_make_image_thumbnail_async (const gchar *filename,
OdsImagingFunc func, gpointer data);
#endif /*__ODS_IMAGING_HELPERS_H_*/
obex-data-server-0.4.6/src/ods-marshal.list 0000644 0001750 0001750 00000000147 11524724173 015520 0000000 0000000 NONE:STRING,STRING,UINT64
NONE:UINT64
NONE:STRING,STRING
NONE:STRING,STRING,STRING
NONE:STRING,BOOLEAN
obex-data-server-0.4.6/src/ods-server.xml 0000644 0001750 0001750 00000003253 11524724173 015225 0000000 0000000
obex-data-server-0.4.6/src/ods-main.c 0000644 0001750 0001750 00000012250 11524724173 014262 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-common.h"
#include "ods-manager.h"
#include "ods-logging.h"
static GMainLoop *main_loop;
static OdsManager *manager = NULL;
static void
manager_disposed_cb (OdsManager *manager, gpointer data)
{
g_message ("quitting main loop");
g_main_loop_quit (main_loop);
}
static void
sig_term (int sig)
{
g_message ("me was killed");
g_signal_connect (manager, "disposed", G_CALLBACK (manager_disposed_cb), NULL);
ods_manager_dispose (manager);
}
static gboolean
ods_service_register (DBusGConnection *connection)
{
DBusGProxy *bus_proxy = NULL;
GError *error = NULL;
guint request_name_result;
bus_proxy = dbus_g_proxy_new_for_name (connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
if (!org_freedesktop_DBus_request_name (bus_proxy,
ODS_DBUS_SERVICE,
0, &request_name_result,
&error)) {
g_critical ("Unable to register service: %s", error->message);
g_clear_error (&error);
g_object_unref (bus_proxy);
return FALSE;
}
/* free the bus_proxy */
g_object_unref (bus_proxy);
/* already running */
if (request_name_result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
g_critical ("Already running in this session");
return FALSE;
}
return TRUE;
}
/**
* main:
**/
int
main (int argc, char *argv[])
{
DBusGConnection *system_connection;
DBusGConnection *session_connection;
GError *error = NULL;
GOptionContext *context;
struct sigaction sa;
gboolean no_daemon = FALSE;
gboolean system_bus = FALSE;
gboolean show_version = FALSE;
gboolean log = FALSE;
gboolean debug = FALSE;
const GOptionEntry options[] = {
{ "no-daemon", 'n', 0, G_OPTION_ARG_NONE, &no_daemon,
"Do not daemonize", NULL },
{ "system-bus", 's', 0, G_OPTION_ARG_NONE, &system_bus,
"Use system bus instead of the default session bus", NULL},
{ "log", 'l', 0, G_OPTION_ARG_NONE, &log,
"Log all messages to syslog", NULL},
{ "debug", 'd', 0, G_OPTION_ARG_NONE, &debug,
"Enable debugging messages", NULL},
{ "version", 'v', 0, G_OPTION_ARG_NONE, &show_version,
"Show version of obex-data-server and exit immediately", NULL},
{ NULL}
};
setlocale (LC_CTYPE, "");
#if defined(USE_IMAGEMAGICK) || defined (USE_GDKPIXBUF)
/* threading is only used for BIP stuff */
g_thread_init (NULL);
#endif
context = g_option_context_new ("");
g_option_context_add_main_entries (context, options, NULL);
if (!g_option_context_parse (context, &argc, &argv, &error)) {
g_warning ("%s", error->message);
g_clear_error (&error);
}
g_option_context_free (context);
g_type_init ();
if (show_version) {
printf (PACKAGE_STRING "\n");
return 0;
}
if (!no_daemon && daemon (0, 0)) {
g_critical ("Could not daemonize: %s", g_strerror (errno));
}
/* init logging stuff */
ods_log_init (PACKAGE_NAME, log, debug);
/* check dbus connections, exit if not valid */
system_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
if (error) {
g_critical ("%s", error->message);
g_clear_error (&error);
return -1;
}
if (!system_bus) {
ODS_DBUS_BUS = DBUS_BUS_SESSION;
g_message ("Using Session bus");
} else {
ODS_DBUS_BUS = DBUS_BUS_SYSTEM;
g_message ("Using System bus");
}
session_connection = dbus_g_bus_get (ODS_DBUS_BUS, &error);
if (error) {
g_critical ("%s", error->message);
g_clear_error (&error);
return -1;
}
if (!ods_service_register (session_connection)) {
return -1;
}
/* create a new manager object */
manager = ods_manager_new ();
if (!ods_manager_is_initialized (manager)) {
g_critical ("Failed to initialize OdsManager object");
g_object_unref (manager);
return -1;
}
main_loop = g_main_loop_new (NULL, FALSE);
memset (&sa, 0, sizeof (sa));
sa.sa_handler = sig_term;
sigaction (SIGTERM, &sa, NULL);
sigaction (SIGINT, &sa, NULL);
g_main_loop_run (main_loop);
g_object_unref (manager);
ods_log_finalize ();
return 0;
}
obex-data-server-0.4.6/src/ods-marshal.c 0000644 0001750 0001750 00000023450 11546317666 015002 0000000 0000000
#include
#ifdef G_ENABLE_DEBUG
#define g_marshal_value_peek_boolean(v) g_value_get_boolean (v)
#define g_marshal_value_peek_char(v) g_value_get_char (v)
#define g_marshal_value_peek_uchar(v) g_value_get_uchar (v)
#define g_marshal_value_peek_int(v) g_value_get_int (v)
#define g_marshal_value_peek_uint(v) g_value_get_uint (v)
#define g_marshal_value_peek_long(v) g_value_get_long (v)
#define g_marshal_value_peek_ulong(v) g_value_get_ulong (v)
#define g_marshal_value_peek_int64(v) g_value_get_int64 (v)
#define g_marshal_value_peek_uint64(v) g_value_get_uint64 (v)
#define g_marshal_value_peek_enum(v) g_value_get_enum (v)
#define g_marshal_value_peek_flags(v) g_value_get_flags (v)
#define g_marshal_value_peek_float(v) g_value_get_float (v)
#define g_marshal_value_peek_double(v) g_value_get_double (v)
#define g_marshal_value_peek_string(v) (char*) g_value_get_string (v)
#define g_marshal_value_peek_param(v) g_value_get_param (v)
#define g_marshal_value_peek_boxed(v) g_value_get_boxed (v)
#define g_marshal_value_peek_pointer(v) g_value_get_pointer (v)
#define g_marshal_value_peek_object(v) g_value_get_object (v)
#define g_marshal_value_peek_variant(v) g_value_get_variant (v)
#else /* !G_ENABLE_DEBUG */
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
* Do not access GValues directly in your code. Instead, use the
* g_value_get_*() functions
*/
#define g_marshal_value_peek_boolean(v) (v)->data[0].v_int
#define g_marshal_value_peek_char(v) (v)->data[0].v_int
#define g_marshal_value_peek_uchar(v) (v)->data[0].v_uint
#define g_marshal_value_peek_int(v) (v)->data[0].v_int
#define g_marshal_value_peek_uint(v) (v)->data[0].v_uint
#define g_marshal_value_peek_long(v) (v)->data[0].v_long
#define g_marshal_value_peek_ulong(v) (v)->data[0].v_ulong
#define g_marshal_value_peek_int64(v) (v)->data[0].v_int64
#define g_marshal_value_peek_uint64(v) (v)->data[0].v_uint64
#define g_marshal_value_peek_enum(v) (v)->data[0].v_long
#define g_marshal_value_peek_flags(v) (v)->data[0].v_ulong
#define g_marshal_value_peek_float(v) (v)->data[0].v_float
#define g_marshal_value_peek_double(v) (v)->data[0].v_double
#define g_marshal_value_peek_string(v) (v)->data[0].v_pointer
#define g_marshal_value_peek_param(v) (v)->data[0].v_pointer
#define g_marshal_value_peek_boxed(v) (v)->data[0].v_pointer
#define g_marshal_value_peek_pointer(v) (v)->data[0].v_pointer
#define g_marshal_value_peek_object(v) (v)->data[0].v_pointer
#define g_marshal_value_peek_variant(v) (v)->data[0].v_pointer
#endif /* !G_ENABLE_DEBUG */
/* NONE:STRING,STRING,UINT64 (src/ods-marshal.list:1) */
void
ods_marshal_VOID__STRING_STRING_UINT64 (GClosure *closure,
GValue *return_value G_GNUC_UNUSED,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint G_GNUC_UNUSED,
gpointer marshal_data)
{
typedef void (*GMarshalFunc_VOID__STRING_STRING_UINT64) (gpointer data1,
gpointer arg_1,
gpointer arg_2,
guint64 arg_3,
gpointer data2);
register GMarshalFunc_VOID__STRING_STRING_UINT64 callback;
register GCClosure *cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 4);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__STRING_STRING_UINT64) (marshal_data ? marshal_data : cc->callback);
callback (data1,
g_marshal_value_peek_string (param_values + 1),
g_marshal_value_peek_string (param_values + 2),
g_marshal_value_peek_uint64 (param_values + 3),
data2);
}
/* NONE:UINT64 (src/ods-marshal.list:2) */
void
ods_marshal_VOID__UINT64 (GClosure *closure,
GValue *return_value G_GNUC_UNUSED,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint G_GNUC_UNUSED,
gpointer marshal_data)
{
typedef void (*GMarshalFunc_VOID__UINT64) (gpointer data1,
guint64 arg_1,
gpointer data2);
register GMarshalFunc_VOID__UINT64 callback;
register GCClosure *cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 2);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__UINT64) (marshal_data ? marshal_data : cc->callback);
callback (data1,
g_marshal_value_peek_uint64 (param_values + 1),
data2);
}
/* NONE:STRING,STRING (src/ods-marshal.list:3) */
void
ods_marshal_VOID__STRING_STRING (GClosure *closure,
GValue *return_value G_GNUC_UNUSED,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint G_GNUC_UNUSED,
gpointer marshal_data)
{
typedef void (*GMarshalFunc_VOID__STRING_STRING) (gpointer data1,
gpointer arg_1,
gpointer arg_2,
gpointer data2);
register GMarshalFunc_VOID__STRING_STRING callback;
register GCClosure *cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 3);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__STRING_STRING) (marshal_data ? marshal_data : cc->callback);
callback (data1,
g_marshal_value_peek_string (param_values + 1),
g_marshal_value_peek_string (param_values + 2),
data2);
}
/* NONE:STRING,STRING,STRING (src/ods-marshal.list:4) */
void
ods_marshal_VOID__STRING_STRING_STRING (GClosure *closure,
GValue *return_value G_GNUC_UNUSED,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint G_GNUC_UNUSED,
gpointer marshal_data)
{
typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1,
gpointer arg_1,
gpointer arg_2,
gpointer arg_3,
gpointer data2);
register GMarshalFunc_VOID__STRING_STRING_STRING callback;
register GCClosure *cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 4);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
callback (data1,
g_marshal_value_peek_string (param_values + 1),
g_marshal_value_peek_string (param_values + 2),
g_marshal_value_peek_string (param_values + 3),
data2);
}
/* NONE:STRING,BOOLEAN (src/ods-marshal.list:5) */
void
ods_marshal_VOID__STRING_BOOLEAN (GClosure *closure,
GValue *return_value G_GNUC_UNUSED,
guint n_param_values,
const GValue *param_values,
gpointer invocation_hint G_GNUC_UNUSED,
gpointer marshal_data)
{
typedef void (*GMarshalFunc_VOID__STRING_BOOLEAN) (gpointer data1,
gpointer arg_1,
gboolean arg_2,
gpointer data2);
register GMarshalFunc_VOID__STRING_BOOLEAN callback;
register GCClosure *cc = (GCClosure*) closure;
register gpointer data1, data2;
g_return_if_fail (n_param_values == 3);
if (G_CCLOSURE_SWAP_DATA (closure))
{
data1 = closure->data;
data2 = g_value_peek_pointer (param_values + 0);
}
else
{
data1 = g_value_peek_pointer (param_values + 0);
data2 = closure->data;
}
callback = (GMarshalFunc_VOID__STRING_BOOLEAN) (marshal_data ? marshal_data : cc->callback);
callback (data1,
g_marshal_value_peek_string (param_values + 1),
g_marshal_value_peek_boolean (param_values + 2),
data2);
}
obex-data-server-0.4.6/src/ods-folder-listing.h 0000644 0001750 0001750 00000002214 11524724173 016264 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_FOLDER_LISTING_H_
#define __ODS_FOLDER_LISTING_H_
#include
gchar* get_folder_listing (const gchar *path, const gchar *root_path,
gboolean allow_write);
#endif /*__ODS_FOLDER_LISTING_H_*/
obex-data-server-0.4.6/src/ods-logging.c 0000644 0001750 0001750 00000015557 11524724173 015001 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
static gboolean syslog_enabled = FALSE;
static gboolean debug_enabled = FALSE;
static struct {
int g_log_level;
int syslog_prio;
const char *prefix;
} log_levels[] = {
{ G_LOG_LEVEL_MESSAGE, LOG_INFO, "" },
{ G_LOG_LEVEL_WARNING, LOG_WARNING, "**Warning" },
{ G_LOG_LEVEL_ERROR, LOG_ERR, "**Error" },
{ G_LOG_LEVEL_DEBUG, LOG_DEBUG, "##DEBUG" },
{ G_LOG_LEVEL_CRITICAL, LOG_CRIT, "**Critical"},
{ G_LOG_LEVEL_INFO, LOG_INFO, "" },
{ 0xFF, 0xFF, "" },
};
static void
log_handler (const gchar *log_domain, GLogLevelFlags log_level,
const gchar *message, gpointer user_data)
{
const char *prefix = "";
int syslog_prio = LOG_INFO;
int i;
char *out = NULL;
/* suppress debug messages if debugging is disabled */
if (!debug_enabled && log_level == G_LOG_LEVEL_DEBUG)
return;
for (i = 0; log_levels[i].g_log_level != 0xFF; i++) {
if (log_levels[i].g_log_level != log_level)
continue;
syslog_prio = log_levels[i].syslog_prio;
prefix = log_levels[i].prefix;
}
if (*prefix != '\0') {
out = g_strdup_printf ("%s: %s", prefix, message);
}
if (syslog_enabled)
syslog (syslog_prio, "%s", out ? out : message);
else
printf ("%s\n", out ? out : message);
g_free (out);
}
void
ods_log_init (const char *ident, gboolean enable_syslog, gboolean enable_debug)
{
g_log_set_handler (NULL, G_LOG_LEVEL_MASK | G_LOG_FLAG_FATAL
| G_LOG_FLAG_RECURSION, log_handler, NULL);
if (enable_syslog)
openlog (ident, LOG_PID | LOG_NDELAY | LOG_PERROR, LOG_DAEMON);
else
printf ("%s\n", PACKAGE_STRING);
syslog_enabled = enable_syslog;
debug_enabled = enable_debug;
}
void
ods_log_finalize ()
{
if (syslog_enabled)
closelog ();
}
static struct {
int evt;
const char *name;
} obex_event[] = {
{ OBEX_EV_PROGRESS, "PROGRESS" }, /* Progress has been made */
{ OBEX_EV_REQHINT, "REQHINT" }, /* An incoming request is about to come */
{ OBEX_EV_REQ, "REQ" }, /* An incoming request has arrived */
{ OBEX_EV_REQDONE, "REQDONE" }, /* Request has finished */
{ OBEX_EV_LINKERR, "LINKERR" }, /* Link has been disconnected */
{ OBEX_EV_PARSEERR, "PARSEERR" }, /* Malformed data encountered */
{ OBEX_EV_ACCEPTHINT, "ACCEPTHINT" }, /* Connection accepted */
{ OBEX_EV_ABORT, "ABORT" }, /* Request was aborted */
{ OBEX_EV_STREAMEMPTY, "STREAMEMPTY" }, /* Need to feed more data when sending a stream */
{ OBEX_EV_STREAMAVAIL, "STREAMAVAIL" }, /* Time to pick up data when receiving a stream */
{ OBEX_EV_UNEXPECTED, "UNEXPECTED" }, /* Unexpected data, not fatal */
{ OBEX_EV_REQCHECK, "REQCHECK" }, /* First packet of an incoming request has been parsed */
{ 0xFF, "" },
};
/* Possible OBEX commands */
static struct {
int cmd;
const char *name;
} obex_command[] = {
{ OBEX_CMD_CONNECT, "CONNECT" },
{ OBEX_CMD_DISCONNECT, "DISCONNECT"},
{ OBEX_CMD_PUT, "PUT" },
{ OBEX_CMD_GET, "GET" },
{ OBEX_CMD_SETPATH, "SETPATH" },
{ OBEX_CMD_SESSION, "SESSION" },
{ OBEX_CMD_ABORT, "ABORT" },
{ OBEX_FINAL, "FINAL" },
{ 0xFF, "" },
};
/* Possible OBEX responses */
static struct {
int rsp;
const char *name;
} obex_response[] = {
{ OBEX_RSP_CONTINUE, "CONTINUE" },
{ OBEX_RSP_SWITCH_PRO, "SWITCH_PRO" },
{ OBEX_RSP_SUCCESS, "SUCCESS" },
{ OBEX_RSP_CREATED, "CREATED" },
{ OBEX_RSP_ACCEPTED, "ACCEPTED" },
{ OBEX_RSP_NON_AUTHORITATIVE, "NON_AUTHORITATIVE" },
{ OBEX_RSP_NO_CONTENT, "NO_CONTENT" },
{ OBEX_RSP_RESET_CONTENT, "RESET_CONTENT" },
{ OBEX_RSP_PARTIAL_CONTENT, "PARTIAL_CONTENT" },
{ OBEX_RSP_MULTIPLE_CHOICES, "MULTIPLE_CHOICES" },
{ OBEX_RSP_MOVED_PERMANENTLY, "MOVED_PERMANENTLY" },
{ OBEX_RSP_MOVED_TEMPORARILY, "MOVED_TEMPORARILY" },
{ OBEX_RSP_SEE_OTHER, "SEE_OTHER" },
{ OBEX_RSP_NOT_MODIFIED, "NOT_MODIFIED" },
{ OBEX_RSP_USE_PROXY, "USE_PROXY" },
{ OBEX_RSP_BAD_REQUEST, "BAD_REQUEST" },
{ OBEX_RSP_UNAUTHORIZED, "UNAUTHORIZED" },
{ OBEX_RSP_PAYMENT_REQUIRED, "PAYMENT_REQUIRED" },
{ OBEX_RSP_FORBIDDEN, "FORBIDDEN" },
{ OBEX_RSP_NOT_FOUND, "NOT_FOUND" },
{ OBEX_RSP_METHOD_NOT_ALLOWED, "METHOD_NOT_ALLOWED" },
{ OBEX_RSP_NOT_ACCEPTABLE, "NOT_ACCEPTABLE" },
{ OBEX_RSP_PROXY_AUTH_REQUIRED, "PROXY_AUTH_REQUIRED" },
{ OBEX_RSP_REQUEST_TIME_OUT, "REQUEST_TIME_OUT" },
{ OBEX_RSP_CONFLICT, "CONFLICT" },
{ OBEX_RSP_GONE, "GONE" },
{ OBEX_RSP_LENGTH_REQUIRED, "LENGTH_REQUIRED" },
{ OBEX_RSP_PRECONDITION_FAILED, "PRECONDITION_FAILED" },
{ OBEX_RSP_REQ_ENTITY_TOO_LARGE, "REQ_ENTITY_TOO_LARGE" },
{ OBEX_RSP_REQ_URL_TOO_LARGE, "REQ_URL_TOO_LARGE" },
{ OBEX_RSP_UNSUPPORTED_MEDIA_TYPE, "UNSUPPORTED_MEDIA_TYPE"},
{ OBEX_RSP_INTERNAL_SERVER_ERROR, "INTERNAL_SERVER_ERROR" },
{ OBEX_RSP_NOT_IMPLEMENTED, "NOT_IMPLEMENTED" },
{ OBEX_RSP_BAD_GATEWAY, "BAD_GATEWAY" },
{ OBEX_RSP_SERVICE_UNAVAILABLE, "SERVICE_UNAVAILABLE" },
{ OBEX_RSP_GATEWAY_TIMEOUT, "GATEWAY_TIMEOUT" },
{ OBEX_RSP_VERSION_NOT_SUPPORTED, "VERSION_NOT_SUPPORTED" },
{ OBEX_RSP_DATABASE_FULL, "DATABASE_FULL" },
{ OBEX_RSP_DATABASE_LOCKED, "DATABASE_LOCKED" },
{ 0xFF, "" },
};
void
ods_log_obex (const char *prefix, int evt, int cmd, int rsp)
{
const char *evtstr = NULL, *cmdstr = NULL, *rspstr = NULL;
int i;
if (!debug_enabled)
return;
for (i = 0; obex_event[i].evt != 0xFF; i++) {
if (obex_event[i].evt != evt)
continue;
evtstr = obex_event[i].name;
}
for (i = 0; obex_command[i].cmd != 0xFF; i++) {
if (obex_command[i].cmd != cmd)
continue;
cmdstr = obex_command[i].name;
}
for (i = 0; obex_response[i].rsp != 0xFF; i++) {
if (obex_response[i].rsp != rsp)
continue;
rspstr = obex_response[i].name;
}
if (prefix) {
g_debug ("%s OBEX event: %s(0x%x), %s(0x%x), %s(0x%x)",
prefix, evtstr, evt, cmdstr, cmd, rspstr, rsp);
}
else {
g_debug ("OBEX event: %s(0x%x), %s(0x%x), %s(0x%x)",
evtstr, evt, cmdstr, cmd, rspstr, rsp);
}
}
obex-data-server-0.4.6/src/ods-folder-listing.c 0000644 0001750 0001750 00000011135 11524724173 016261 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include "ods-common.h"
#define FL_XML_VERSION "" EOL_CHARS
#define FL_XML_TYPE "" EOL_CHARS
#define FL_XML_BODY_BEGIN "" EOL_CHARS
#define FL_XML_BODY_END "" EOL_CHARS
#define FL_XML_PARENT_FOLDER_ELEMENT "" EOL_CHARS
#define FL_XML_FILE_ELEMENT "" EOL_CHARS
#define FL_XML_FOLDER_ELEMENT "" EOL_CHARS
inline static gchar *
get_permission_string (mode_t file, mode_t folder, gboolean allow_write)
{
return g_strdup_printf (
"user-perm=\"%s%s%s\" group-perm=\"%s%s%s\" other-perm=\"%s%s%s\"",
(file & S_IRUSR ? "R" : ""),
(file & S_IWUSR && allow_write ? "W" : ""),
(folder & S_IWUSR ? "D" : ""),
(file & S_IRGRP ? "R" : ""),
(file & S_IWGRP && allow_write ? "W" : ""),
(folder & S_IWGRP ? "D" : ""),
(file & S_IROTH ? "R" : ""),
(file & S_IWOTH && allow_write ? "W" : ""),
(folder & S_IWOTH ? "D" : ""));
}
gchar*
get_folder_listing (const gchar *path, const gchar *root_path, gboolean allow_write)
{
GString *listing;
struct dirent *dirp;
DIR *dp;
struct stat dirstat;
struct stat filestat;
gchar *filename = NULL;
gchar *filename_utf8;
GError *error = NULL;
gboolean is_dir;
gchar *perm_str = NULL;
gchar atime_str[17];
gchar mtime_str[17];
gchar ctime_str[17];
listing = g_string_new ("");
listing = g_string_append (listing, FL_XML_VERSION);
listing = g_string_append (listing, FL_XML_TYPE);
listing = g_string_append (listing, FL_XML_BODY_BEGIN);
/* Add parent folder element if path!=root_path */
if (strcmp (path, root_path))
listing = g_string_append (listing, FL_XML_PARENT_FOLDER_ELEMENT);
/* Go through directory, add file and folder elements */
stat (path, &dirstat);
dp = opendir (path);
while (dp != NULL && (dirp = readdir (dp))) {
if (dirp->d_name[0] == '.')
continue;
filename = g_build_filename (path, dirp->d_name, NULL);
filename_utf8 = g_filename_to_utf8 (dirp->d_name, -1, NULL, NULL, &error);
if (filename_utf8 == NULL) {
g_message ("get_folder_listing error: %s", error->message);
g_clear_error (&error);
/* continue anyway */
g_free (filename);
continue;
}
/* stat file */
lstat (filename, &filestat);
is_dir = S_ISDIR (filestat.st_mode);
/* get permission string */
perm_str = get_permission_string (filestat.st_mode, dirstat.st_mode,
allow_write);
/* get time strings */
ods_make_iso8601 (filestat.st_atime, atime_str, sizeof (atime_str));
ods_make_iso8601 (filestat.st_mtime, mtime_str, sizeof (mtime_str));
ods_make_iso8601 (filestat.st_ctime, ctime_str, sizeof (ctime_str));
if (is_dir) {
g_string_append_printf (listing, FL_XML_FOLDER_ELEMENT,
filename_utf8, perm_str, atime_str,
mtime_str, ctime_str);
} else {
g_string_append_printf (listing, FL_XML_FILE_ELEMENT,
filename_utf8, (guint64) filestat.st_size,
perm_str, atime_str, mtime_str, ctime_str);
}
/* free mem */
g_free (filename);
g_free (filename_utf8);
g_free (perm_str);
}
closedir (dp);
listing = g_string_append (listing, FL_XML_BODY_END);
return g_string_free (listing, FALSE);
}
obex-data-server-0.4.6/src/ods-manager.xml 0000644 0001750 0001750 00000007357 11524724173 015342 0000000 0000000
obex-data-server-0.4.6/src/ods-obex.c 0000644 0001750 0001750 00000161023 11524726202 014271 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
* Parts of code taken from osso-gwobex library by:
* Johan Hedberg
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-capabilities.h"
#include "ods-common.h"
#include "ods-folder-listing.h"
#include "ods-imaging-helpers.h"
#include "ods-obex.h"
#include "ods-session.h"
#include "ods-error.h"
#define ATTACHMENT_FILENAME "attachment"
static void
get_target_size_and_time (obex_t *handle, obex_object_t *object,
guint64 *size, time_t *time)
{
obex_headerdata_t hv;
uint8_t hi;
unsigned int hlen;
*size = 0;
*time = -1;
while (OBEX_ObjectGetNextHeader(handle, object, &hi, &hv, &hlen)) {
switch (hi) {
case OBEX_HDR_LENGTH:
*size = hv.bq4;
break;
case OBEX_HDR_TIME:
*time = ods_parse_iso8601 ((char *)hv.bs, hlen);
break;
default:
break;
}
}
OBEX_ObjectReParseHeaders (handle, object);
}
/**
* ods_process_usb_input:
* @data: obex_t handle
*
* Idle callback that reads data from a USB interface
*
* Return value: whether there is more data to read
**/
static gboolean
ods_process_usb_input (gpointer data)
{
OdsObexContext *ctxt = (OdsObexContext *) data;
int i = OBEX_HandleInput (ctxt->obex_handle, 1);
if (i <= 0) {
/* Link error: for example USB cable was disconnected */
(ctxt->io_callback) (NULL, G_IO_ERR, ctxt->obex_handle);
return FALSE;
}
return ctxt->usb_read_more;
}
static gboolean
ods_obex_timeout (gpointer data)
{
OdsObexContext *ctxt = (OdsObexContext *) data;
obex_object_t *object;
g_message ("Request timeout (%ds), session considered dead", ODS_OBEX_TIMEOUT);
ctxt->timeout_id = 0;
/* issue dummy obex_event with OBEX_RSP_REQUEST_TIME_OUT */
if (ctxt->obex_event) {
object = OBEX_ObjectNew(ctxt->obex_handle, ctxt->obex_cmd);
(ctxt->obex_event) (ctxt->obex_handle, object, 0,
OBEX_EV_REQDONE, ctxt->obex_cmd,
OBEX_RSP_REQUEST_TIME_OUT);
OBEX_ObjectDelete (ctxt->obex_handle, object);
}
/* issue dummy io_callback with G_IO_ERR condition
* (so that session gets disconnected)
* also check that io_callback is not null (in some cases obex_context
* might have been already closed (ods_obex_close_transport() was called),
* e.g. when CMD_CONNECT times out) */
if (ctxt->io_callback) {
(ctxt->io_callback) (NULL, G_IO_ERR, ctxt->obex_handle);
}
/* immediately remove io watch, we consider this connection dead */
ods_safe_gsource_remove (&(ctxt->io_watch));
return FALSE;
}
static gint
ods_obex_send (OdsObexContext *ctxt, obex_object_t *object)
{
int err;
OdsSession* session;
gint usbintfnum;
ctxt->obex_cmd = OBEX_ObjectGetCommand (ctxt->obex_handle, object);
err = OBEX_Request (ctxt->obex_handle, object);
if (err == -EBUSY) {
g_warning ("EBUSY in ods_session_obex_send");
}
if (err >=0 ) {
session = ODS_SESSION (OBEX_GetUserData (ctxt->obex_handle));
g_object_get (session, "usbintfnum", &usbintfnum, NULL);
if (usbintfnum >= 0) {
/* It is not possible to use io_watch with USB,
* so data is read in a custom idle callback function */
g_idle_add ((GSourceFunc)ods_process_usb_input, ctxt);
}
ctxt->timeout_id = g_timeout_add_seconds (ODS_OBEX_TIMEOUT,
ods_obex_timeout, ctxt);
}
return err;
}
static gboolean
ods_obex_io (GIOChannel *io_channel, GIOCondition cond, gpointer data)
{
OdsObexContext *ctxt = (OdsObexContext *) data;
/* got data or error so cancel request timeout (if set) */
ods_safe_gsource_remove (&(ctxt->timeout_id));
/* call real io_callback */
return (ctxt->io_callback) (io_channel, cond, ctxt->obex_handle);
}
static gchar *
ods_obex_get_new_path (const gchar *folder, const gchar *filename)
{
gchar *path;
gchar *new_path;
guint iterator = 2;
gchar *first_part;
gchar *extension;
gchar *parentess;
guint pos;
/* In case we don't know what the filename is (HDR_NAME wasn't received) */
if (filename == NULL || *filename == '\0')
filename = "Unknown";
path = g_build_filename (folder, filename, NULL);
new_path = g_strdup (path);
extension = g_strrstr (path, ".");
if (!extension)
extension = "";
while (g_file_test (new_path, G_FILE_TEST_EXISTS)) {
if (iterator == 2) {
parentess = g_strrstr (new_path, "(");
if (parentess != NULL && !g_str_has_prefix (parentess, "(2)"))
parentess = NULL;
pos = parentess ? strlen (parentess) : strlen (extension);
pos = strlen (new_path) - pos;
} else {
parentess = g_strrstr (new_path, "(");
pos = strlen (new_path) - strlen (parentess);
}
first_part = g_strndup (new_path, pos);
g_free (new_path);
new_path = g_strdup_printf ("%s(%d)%s", first_part, iterator, extension);
g_free (first_part);
iterator++;
}
g_free (path);
return new_path;
}
void
ods_obex_transfer_new (OdsObexContext *obex_context, const gchar *local,
const gchar *remote, const gchar *type)
{
obex_context->local = g_strdup (local);
obex_context->remote = g_strdup (remote);
obex_context->type = g_strdup (type);
obex_context->target_size = 0;
obex_context->modtime = -1;
obex_context->report_progress = TRUE; /* by default */
obex_context->transfer_started_signal_emitted = FALSE;
obex_context->cancelled = FALSE;
obex_context->suspend_result = 0;
obex_context->buf_size = 0;
obex_context->buf = NULL;
obex_context->stream_fd = -1;
obex_context->counter = 0;
}
static gboolean
ods_obex_susp_timeout (gpointer data)
{
OdsObexContext *ctxt = (OdsObexContext *) data;
g_message ("Suspend timeout (%ds), rejecting incoming file", ODS_OBEX_TIMEOUT);
ctxt->suspend_timeout_id = 0;
ctxt->suspend_result = OBEX_SUSP_REJECTED;
return FALSE;
}
void
ods_obex_transfer_suspend (OdsObexContext *ctxt)
{
g_message ("Suspending request");
ctxt->suspend_timeout_id = g_timeout_add_seconds (ODS_OBEX_TIMEOUT,
ods_obex_susp_timeout, ctxt);
while (!ctxt->suspend_result)
g_main_context_iteration (NULL, TRUE);
ods_safe_gsource_remove (&(ctxt->suspend_timeout_id));
g_message ("Suspend result: %d", ctxt->suspend_result);
}
void
ods_obex_transfer_close (OdsObexContext *obex_context)
{
if (obex_context->local) {
g_free (obex_context->local);
obex_context->local = NULL;
}
if (obex_context->remote) {
g_free (obex_context->remote);
obex_context->remote = NULL;
}
if (obex_context->type) {
g_free (obex_context->type);
obex_context->type = NULL;
}
if (obex_context->img_handle) {
g_free (obex_context->img_handle);
obex_context->img_handle = NULL;
}
if (obex_context->ext_info) {
g_hash_table_unref (obex_context->ext_info);
obex_context->ext_info = NULL;
}
if (obex_context->buf) {
g_free (obex_context->buf);
obex_context->buf = NULL;
}
if (obex_context->fifo_watch > 0) {
g_source_remove (obex_context->fifo_watch);
obex_context->fifo_watch = 0;
}
if (obex_context->stream_fd >= 0)
close (obex_context->stream_fd);
}
void
ods_obex_transfer_add_info (OdsObexContext *obex_context, gchar *key,
gchar *value)
{
if (!key || !value)
return;
if (!obex_context->ext_info) {
obex_context->ext_info = g_hash_table_new_full (g_str_hash,
g_str_equal, NULL, g_free);
}
g_hash_table_insert (obex_context->ext_info, key, value);
}
GHashTable*
ods_obex_transfer_get_info (OdsObexContext *obex_context)
{
GHashTable *info;
gchar *time_str;
GHashTableIter iter;
gpointer key, value;
info = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free);
g_hash_table_insert (info, "LocalPath", g_strdup (obex_context->local));
g_hash_table_insert (info, "RemoteFilename", g_strdup (obex_context->remote));
g_hash_table_insert (info, "Size",
g_strdup_printf ("%" G_GUINT64_FORMAT,
obex_context->target_size));
if (obex_context->type)
g_hash_table_insert (info, "Type", g_strdup (obex_context->type));
if (obex_context->modtime != -1) {
time_str = (gchar *)g_malloc (17);
ods_make_iso8601 (obex_context->modtime, time_str, sizeof (time_str));
g_hash_table_insert (info, "Time", time_str);
}
if (obex_context->obex_cmd == OBEX_CMD_GET)
g_hash_table_insert (info, "OBEXCommand", g_strdup ("GET"));
else if (obex_context->obex_cmd == OBEX_CMD_PUT)
g_hash_table_insert (info, "OBEXCommand", g_strdup ("PUT"));
if (obex_context->img_handle)
g_hash_table_insert (info, "ImageHandle",
g_strdup (obex_context->img_handle));
/* Add additional transfer info (if any) */
if (obex_context->ext_info) {
g_hash_table_iter_init (&iter, obex_context->ext_info);
while (g_hash_table_iter_next (&iter, &key, &value))
g_hash_table_insert (info, key, g_strdup (value));
}
return info;
}
OdsObexContext*
ods_obex_context_new (void)
{
OdsObexContext *obex_context = g_new0 (OdsObexContext, 1);
obex_context->rx_max = ODS_DEFAULT_RX_MTU;
obex_context->tx_max = ODS_DEFAULT_TX_MTU - 200;
obex_context->connection_id = CONID_INVALID;
obex_context->stream_fd = -1;
return obex_context;
}
gboolean
ods_obex_setup_fdtransport (OdsObexContext *obex_context, gint fd,
guint16 rx_mtu, guint16 tx_mtu,
obex_event_t eventcb, GIOFunc io_cb,
gpointer user_data, GError **error)
{
GIOChannel *chan;
gint ret;
/* call OBEX_Init, setup FD Transport here */
obex_context->obex_event = eventcb;
obex_context->io_callback = io_cb;
obex_context->obex_handle = OBEX_Init (OBEX_TRANS_FD, eventcb, 0);
if (obex_context->obex_handle == NULL) {
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED, "Out of memory");
return FALSE;
}
OBEX_SetUserData (obex_context->obex_handle, user_data);
OBEX_SetTransportMTU (obex_context->obex_handle, rx_mtu, tx_mtu);
g_message ("Used MTUs: RX=%u, TX=%u", rx_mtu, tx_mtu);
ret = FdOBEX_TransportSetup (obex_context->obex_handle, fd, fd, 0);
if (ret < 0) {
OBEX_Cleanup (obex_context->obex_handle);
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED, "Transport setup failed");
return FALSE;
}
chan = g_io_channel_unix_new (fd);
obex_context->io_watch = g_io_add_watch(chan,
G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
ods_obex_io, obex_context);
g_io_channel_unref(chan);
return obex_context->io_watch ? TRUE : FALSE;
}
gboolean
ods_obex_setup_usbtransport (OdsObexContext *obex_context, gint intf_num,
obex_event_t eventcb, GIOFunc io_cb,
gpointer user_data, GError **error)
{
gint ret;
obex_interface_t *obex_intf;
int interfaces_num;
/* call OBEX_Init, setup USB Transport here */
obex_context->obex_event = eventcb;
obex_context->io_callback = io_cb;
obex_context->obex_handle = OBEX_Init (OBEX_TRANS_USB, eventcb, 0);
if (obex_context->obex_handle == NULL) {
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED, "Out of memory");
goto err;
}
interfaces_num = OBEX_FindInterfaces(obex_context->obex_handle, &obex_intf);
if (intf_num >= interfaces_num) {
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED, "Invalid interface number");
goto err;
}
OBEX_SetUserData (obex_context->obex_handle, user_data);
ret = OBEX_InterfaceConnect(obex_context->obex_handle, &obex_intf[intf_num]);
if (ret < 0) {
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED, "USB setup failed");
goto err;
}
return TRUE;
err:
if (obex_context->obex_handle)
OBEX_Cleanup (obex_context->obex_handle);
return FALSE;
}
void
ods_obex_close_transport (OdsObexContext *ctxt)
{
ods_safe_gsource_remove (&(ctxt->timeout_id));
ods_safe_gsource_remove (&(ctxt->io_watch));
ctxt->obex_event = NULL;
ctxt->io_callback = NULL;
}
gchar *
ods_obex_get_buffer_as_string (OdsObexContext *obex_context)
{
/* put /0 in the end */
obex_context->buf = g_realloc (obex_context->buf, obex_context->buf_size+1);
obex_context->buf[obex_context->buf_size] = 0;
return (gchar *)obex_context->buf;
}
gboolean
ods_obex_srv_new_file (OdsObexContext *obex_context, const gchar *path)
{
/* Get local path */
obex_context->local = ods_obex_get_new_path (path, obex_context->remote);
/* open local file for writing */
obex_context->stream_fd = open (obex_context->local, O_WRONLY | O_CREAT, 0666);
return obex_context->stream_fd >= 0;
}
gint
ods_obex_connect_done (OdsObexContext *obex_context,
obex_object_t *object)
{
obex_headerdata_t hv;
uint8_t hi;
unsigned int hlen;
uint8_t *ptr;
if (OBEX_ObjectGetNonHdrData (object, &ptr)
!= sizeof (obex_connect_hdr_t)) {
return -1;
} else {
obex_connect_hdr_t *nonhdrdata = (obex_connect_hdr_t *) ptr;
uint16_t mtu = g_ntohs( nonhdrdata->mtu);
int new_size;
g_message ("Version: 0x%02x. Flags: 0x%02x OBEX packet length: %d",
nonhdrdata->version, nonhdrdata->flags, mtu);
/* Leave space for headers */
new_size = mtu - 200;
if (new_size < obex_context->tx_max) {
g_message ("Resizing stream chunks to %d", new_size);
obex_context->tx_max = new_size;
}
}
/* parse headers */
while (OBEX_ObjectGetNextHeader(obex_context->obex_handle, object,
&hi, &hv, &hlen)) {
switch (hi) {
case OBEX_HDR_CONNECTION:
obex_context->connection_id = hv.bq4;
break;
default:
break;
}
}
return 0;
}
gint
ods_obex_connect (OdsObexContext *obex_context, const guchar *uuid,
guint uuid_length)
{
obex_object_t *object;
obex_headerdata_t hd;
int ret;
object = OBEX_ObjectNew(obex_context->obex_handle, OBEX_CMD_CONNECT);
if (!object) {
return -ENOMEM;
}
/* Add target header */
if (uuid) {
hd.bs = uuid;
ret = OBEX_ObjectAddHeader(obex_context->obex_handle, object,
OBEX_HDR_TARGET, hd, uuid_length,
OBEX_FL_FIT_ONE_PACKET);
if (ret < 0) {
OBEX_ObjectDelete(obex_context->obex_handle, object);
return ret;
}
}
ret = ods_obex_send(obex_context, object);
if (ret < 0)
OBEX_ObjectDelete(obex_context->obex_handle, object);
return ret;
}
gint
ods_obex_srv_connect (OdsObexContext *obex_context, obex_object_t *object,
guint service)
{
obex_headerdata_t hv;
uint8_t hi;
guint hlen;
uint8_t *ptr;
const guchar *target = NULL;
guint target_len = 0;
obex_headerdata_t hd;
gint ret;
if (OBEX_ObjectGetNonHdrData (object, &ptr)
!= sizeof (obex_connect_hdr_t)) {
return -1;
} else {
obex_connect_hdr_t *nonhdrdata = (obex_connect_hdr_t *) ptr;
uint16_t mtu = g_ntohs (nonhdrdata->mtu);
int new_size;
g_message ("Version: 0x%02x. Flags: 0x%02x OBEX packet length: %d",
nonhdrdata->version, nonhdrdata->flags, mtu);
/* Leave space for headers */
new_size = mtu - 200;
if (new_size < obex_context->tx_max) {
g_message ("Resizing stream chunks to %d", new_size);
obex_context->tx_max = new_size;
}
}
/* parse headers */
while (OBEX_ObjectGetNextHeader(obex_context->obex_handle, object,
&hi, &hv, &hlen)) {
if (hi == OBEX_HDR_TARGET) {
target = hv.bs;
target_len = hlen;
}
}
OBEX_ObjectReParseHeaders (obex_context->obex_handle, object);
switch (service) {
case ODS_SERVICE_FTP:
/* Target header must be F9EC7BC4-953C-11D2-984E-525400DC9E09*/
if (!target || memcmp(OBEX_FTP_UUID, target, hlen) != 0) {
g_message("Target header Incorrect");
goto fail;
}
break;
case ODS_SERVICE_PBAP:
/* Target header must be 796135f0-f0c5-11d8-0966-0800200c9a66 */
if (!target || memcmp(OBEX_PBAP_UUID, target, hlen) != 0) {
g_message("Target header Incorrect");
goto fail;
}
break;
case ODS_SERVICE_BIP:
if (!target) {
g_message("No Target header received for BIP connection");
goto fail;
}
if (!memcmp (OBEX_BIP_IPUSH_UUID, target, hlen))
break;
if (!memcmp (OBEX_BIP_RD_UUID, target, hlen))
break;
g_message ("Unsupported Imaging feature requested");
goto fail;
case ODS_SERVICE_OPP:
/* Target header must not be used */
if (target) {
g_message("Target header must not be used");
goto fail;
}
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
return 0;
default:
goto fail;
}
hd.bs = target;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_WHO, hd, target_len,
OBEX_FL_FIT_ONE_PACKET);
if (ret < 0) {
OBEX_ObjectDelete (obex_context->obex_handle, object);
return ret;
}
hd.bs = NULL;
hd.bq4 = 1; /* Connection ID is always 1 */
obex_context->connection_id = 1;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hd, 4,
OBEX_FL_FIT_ONE_PACKET);
if (ret < 0) {
OBEX_ObjectDelete (obex_context->obex_handle, object);
return ret;
}
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
return 0;
fail:
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
return 0;
}
gint
ods_obex_disconnect (OdsObexContext *obex_context)
{
obex_object_t *object;
gint ret;
g_message ("Sending CMD_DISCONNECT");
object = OBEX_ObjectNew(obex_context->obex_handle, OBEX_CMD_DISCONNECT);
if (!object) {
return -ENOMEM;
}
/* Add connection header */
if (obex_context->connection_id != CONID_INVALID) {
obex_headerdata_t hv;
hv.bq4 = obex_context->connection_id;
ret = OBEX_ObjectAddHeader(obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hv, 4, 0);
if (ret < 0) {
OBEX_ObjectDelete(obex_context->obex_handle, object);
return ret;
}
}
ret = ods_obex_send (obex_context, object);
if (ret < 0)
OBEX_ObjectDelete(obex_context->obex_handle, object);
return ret;
}
static gboolean
fifo_watch (GIOChannel *io_channel, GIOCondition cond, gpointer data)
{
OdsObexContext *obex_context = (OdsObexContext*) data;
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
obex_context->suspend_result = OBEX_SUSP_FIFO_ERR;
return FALSE;
}
obex_context->suspend_result = OBEX_SUSP_FIFO_ACT;
return TRUE;
}
gint
ods_obex_readstream (OdsObexContext *obex_context, obex_object_t *object)
{
const uint8_t *buf;
gint actual;
gint written = 0;
gint write_ret;
gint ret = 0;
if (obex_context->target_size == 0 && obex_context->counter == 0) {
/* first data came in, get size and time */
get_target_size_and_time (obex_context->obex_handle, object,
&obex_context->target_size,
&obex_context->modtime);
}
if (obex_context->cancelled) {
/* It's not possible to cancel incoming request by sending CMD_ABORT
* hence we set RSP_FORBIDDEN response */
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
ret = 2;
goto out;
}
actual = OBEX_ObjectReadStream (obex_context->obex_handle, object, &buf);
if (actual > 0) {
g_message ("There is some data");
obex_context->counter += actual;
if (obex_context->stream_fd >= 0) {
/* write data to file */
while (written < actual) {
write_ret = write (obex_context->stream_fd, buf + written,
actual - written);
written += write_ret;
if (write_ret < 0) {
if (errno == EINTR)
continue;
else if (errno == EAGAIN) {
/* FIFO is full, wait for it to be read */
ods_obex_transfer_suspend (obex_context);
if (obex_context->suspend_result == OBEX_SUSP_FIFO_ACT) {
obex_context->suspend_result = 0;
/* FIFO was read, we can continue writing */
continue;
} else {
obex_context->suspend_result = 0;
/* FIFO error, cancel transfer */
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
ret = 2;
goto out;
}
} else {
ret = -errno;
goto out;
}
}
}
} else {
g_message ("Writing to buf");
/* write data to internal buffer */
obex_context->buf = g_realloc (obex_context->buf,
obex_context->counter);
memcpy (&obex_context->buf[obex_context->buf_size], buf, actual);
obex_context->buf_size = obex_context->counter;
}
} else {
/* No data on OBEX stream */
ret = 1;
}
out:
if (ret < 0) {
/* close this transfer */
ods_obex_transfer_close (obex_context);
}
return ret;
}
gint
ods_obex_writestream (OdsObexContext *obex_context, obex_object_t *object)
{
g_message ("obex_writestream");
obex_headerdata_t hv;
gint actual = -1;
gint read_bytes = 0;
gint ret = 0;
if (obex_context->stream_fd >= 0) {
g_message ("writestream from File: %d", obex_context->stream_fd);
hv.bs = obex_context->buf;
while (read_bytes < obex_context->tx_max) {
actual = read (obex_context->stream_fd, obex_context->buf+read_bytes,
obex_context->tx_max-read_bytes);
read_bytes += actual;
if (actual > 0) {
obex_context->counter += actual;
if (read_bytes < obex_context->tx_max) {
if (obex_context->fifo_watch > 0) {
g_message ("FIFO (read less than needed), waiting for data");
fifo_suspend:
ods_obex_transfer_suspend (obex_context);
if (obex_context->suspend_result == OBEX_SUSP_FIFO_ACT) {
obex_context->suspend_result = 0;
/* FIFO has more data, we can read */
g_message ("FIFO (continue reading)");
continue;
} else {
obex_context->suspend_result = 0;
/* FIFO error, cancel transfer */
g_message ("FIFO (reading failed)");
OBEX_CancelRequest (obex_context->obex_handle, TRUE);
ret = 2;
goto out;
}
} else
break;
}
} else if (actual == 0 && read_bytes == 0) {
g_message ("read 0 bytes (EOF)");
/* EOF */
OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_DATAEND);
/* transfer done */
ret = 1;
goto out;
} else {
if (obex_context->fifo_watch > 0 && errno == EAGAIN)
goto fifo_suspend;
else {
g_message ("read error %s", strerror (errno));
/* error reading file */
ret = -errno;
goto out;
}
}
}
if (read_bytes > 0) {
OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, read_bytes,
OBEX_FL_STREAM_DATA);
/* Everything OK, continue sending data */
ret = 0;
}
} else if (obex_context->buf_size > 0) {
g_message ("writestream from Buffer");
/* used only in server mode to send folder listings and such */
actual = obex_context->buf_size - obex_context->counter;
if (actual > obex_context->tx_max)
actual = obex_context->tx_max;
g_message ("buf_size: %" G_GUINT64_FORMAT ", actual: %d",
obex_context->buf_size, actual);
hv.bs = &obex_context->buf[obex_context->counter];
if (actual > 0) {
OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, actual,
OBEX_FL_STREAM_DATA);
obex_context->counter += actual;
/* Everything OK, continue sending data */
ret = 0;
} else if (actual == 0) {
/* EOF */
OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, 0,
OBEX_FL_STREAM_DATAEND);
/* transfer done */
ret = 1;
}
} else {
/* shouldn't happen */
g_warning ("Invalid fd while transfer in progress");
ret = -1;
}
out:
if (ret < 0) {
/* close this transfer */
ods_obex_transfer_close (obex_context);
}
return ret;
}
gint
ods_obex_get (OdsObexContext *obex_context,
const gchar *local, const gchar *remote,
const gchar *type, gboolean is_fifo)
{
gint ret;
obex_headerdata_t hv;
obex_object_t *object;
gchar *uname;
gsize uname_len = 0;
g_assert (remote || type);
ods_obex_transfer_new (obex_context, local, remote, type);
object = OBEX_ObjectNew (obex_context->obex_handle, OBEX_CMD_GET);
if (!object) {
ret = -ENOMEM;
goto out;
}
/* Add connection header */
if (obex_context->connection_id != CONID_INVALID) {
hv.bq4 = obex_context->connection_id;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hv, 4, 0);
if (ret < 0)
goto out;
}
/* Add type header */
if (type) {
hv.bs = (guchar *)type;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_TYPE, hv, strlen (type) + 1, 0);
if (ret < 0)
goto out;
}
/* Add name header */
if (remote) {
uname_len = ods_filename_to_utf16 (&uname, remote);
if (uname == NULL) {
ret = -EINVAL;
goto out;
}
/* OpenOBEX is buggy and won't append the header unless hv.bs != NULL */
hv.bs = (guchar *) uname;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_NAME, hv, uname_len, 0);
if (ret < 0)
goto out;
}
/* Add local name header */
if (local) {
int oflags;
if (is_fifo)
oflags = O_WRONLY | O_NONBLOCK;
else
oflags = O_WRONLY | O_CREAT;
obex_context->stream_fd = open (local, oflags, 0666);
if (obex_context->stream_fd < 0) {
ret = -errno;
goto out;
}
if (is_fifo) {
GIOChannel *chan;
/* Setup IO watch to know when it is possible to write to FIFO or error happens */
chan = g_io_channel_unix_new (obex_context->stream_fd);
obex_context->fifo_watch = g_io_add_watch (chan,
G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
fifo_watch, obex_context);
g_io_channel_unref (chan);
}
} else {
/* don't report progress when receiving to internal buffer only */
obex_context->report_progress = FALSE;
}
/* Initiate transfer */
OBEX_ObjectReadStream (obex_context->obex_handle, object, NULL);
ret = ods_obex_send (obex_context, object);
out:
if (uname_len > 0)
g_free (uname);
if (ret < 0 && object)
OBEX_ObjectDelete (obex_context->obex_handle, object);
if (ret < 0 && obex_context->stream_fd >= 0)
g_unlink (obex_context->local); /* delete incomplete file */
if (ret < 0)
ods_obex_transfer_close (obex_context);
return ret;
}
gint
ods_obex_srv_get (OdsObexContext *obex_context, obex_object_t *object,
const gchar *current_path, const gchar *root_path,
gboolean allow_write)
{
obex_headerdata_t hv;
uint8_t hi;
guint hlen;
gint object_size = 0;
time_t object_time = -1;
gint ret;
g_message ("stream_fd=%d", obex_context->stream_fd);
while (OBEX_ObjectGetNextHeader (obex_context->obex_handle, object,
&hi, &hv, &hlen)) {
switch (hi) {
case OBEX_HDR_NAME:
if (hlen == 0) {
/* This is GET by Type, leave remote = NULL */
break;
}
obex_context->remote = ods_filename_from_utf16 ((gchar *) hv.bs, hlen);
break;
case OBEX_HDR_TYPE:
if (hv.bs[hlen - 1] != '\0' ||
!g_utf8_validate ((const gchar *) hv.bs, -1, NULL)) {
/* invalid type header */
g_message ("HDR_TYPE invalid: %s", (gchar*) hv.bs);
}
else {
obex_context->type = g_strdup ((const gchar *) hv.bs);
g_message ("HDR_TYPE: %s", obex_context->type);
}
break;
case OBEX_HDR_CONNECTION:
if (obex_context->connection_id != CONID_INVALID &&
hv.bq4 != obex_context->connection_id) {
/* wrong connection id */
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_BAD_REQUEST, OBEX_RSP_BAD_REQUEST);
goto out;
}
break;
default:
break;
}
}
if (obex_context->remote && ((obex_context->type==NULL) || strcmp (obex_context->type, LST_TYPE))) {
/* If we have name header but type is NOT x-obex/folder-listing */
obex_context->local = g_build_filename (current_path,
obex_context->remote,
NULL);
g_message ("local filename: %s", obex_context->local);
/* Check if such file exists */
if (!g_file_test (obex_context->local, G_FILE_TEST_EXISTS)) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
goto out;
}
if (!g_file_test (obex_context->local, G_FILE_TEST_IS_REGULAR)) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
goto out;
}
if (g_access (obex_context->local, R_OK) < 0) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED, OBEX_RSP_UNAUTHORIZED);
goto out;
}
}
if (obex_context->remote)
g_message ("name: %s", obex_context->remote);
if (obex_context->type)
g_message ("type: %s", obex_context->type);
OBEX_ObjectReParseHeaders (obex_context->obex_handle, object);
if (obex_context->local) {
g_message ("Serving local file");
/* open local file for reading */
obex_context->stream_fd = open (obex_context->local, O_RDONLY);
if (obex_context->stream_fd < 0) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR, OBEX_RSP_INTERNAL_SERVER_ERROR);
goto out;
}
/* allocate buffer */
obex_context->buf = g_malloc (obex_context->tx_max);
obex_context->buf_size = obex_context->tx_max;
/* Try to figure out modification time and size */
struct stat stats;
if (fstat (obex_context->stream_fd, &stats) == 0) {
object_size = stats.st_size;
object_time = stats.st_mtime;
obex_context->modtime = object_time;
}
/* Add a time header */
if (object_time >= 0) {
gchar tstr[17];
gint len;
len = ods_make_iso8601 (object_time, tstr, sizeof (tstr));
if (len >= 0) {
hv.bs = (guchar *)tstr;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_TIME, hv, len, 0);
if (ret < 0) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR, OBEX_RSP_INTERNAL_SERVER_ERROR);
goto out;
}
}
}
/* Add a length header */
if (object_size > 0) {
obex_context->target_size = object_size;
hv.bq4 = (uint32_t)object_size;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_LENGTH, hv, 4, 0);
if (ret < 0) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_INTERNAL_SERVER_ERROR, OBEX_RSP_INTERNAL_SERVER_ERROR);
goto out;
}
} else {
obex_context->target_size = 0;
}
} else if (obex_context->type) {
/* Don't report progress for object GET by type */
obex_context->report_progress = FALSE;
if (!strcmp (obex_context->type, LST_TYPE)) {
gchar *new_path = NULL;
g_message ("Serving FOLDER LISTING object");
if (obex_context->remote) {
/* We need to use some subfolder if we have NAME header */
new_path = g_build_filename (current_path,
obex_context->remote, NULL);
if (!g_file_test (new_path, G_FILE_TEST_IS_DIR)) {
g_free (new_path);
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
goto out;
}
}
/* write folder listing to buffer */
obex_context->buf = (guchar*) get_folder_listing (
new_path ? new_path : current_path,
root_path, allow_write);
g_free (new_path);
} else if (!strcmp (obex_context->type, CAP_TYPE)) {
g_message ("Serving CAPABILITY object");
obex_context->buf = (guchar*) ods_get_capability (root_path);
} else if (!strcmp (obex_context->type, BIP_CAPABILITIES_TYPE)) {
g_message ("Serving IMAGING CAPABILITIES object");
obex_context->buf = (guchar*) ods_get_imaging_capabilities ();
} else {
/* currently no other types are supported */
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED, OBEX_RSP_NOT_IMPLEMENTED);
goto out;
}
if (!obex_context->buf) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
goto out;
}
g_message ("Object: %s", (gchar*) obex_context->buf);
obex_context->buf_size = strlen ((gchar*) obex_context->buf);
g_message ("Object length: %" G_GUINT64_FORMAT, obex_context->buf_size);
} else {
/* neither name nor type was specified */
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_BAD_REQUEST, OBEX_RSP_BAD_REQUEST);
goto out;
}
/* Add body header */
hv.bs = NULL;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, 0, OBEX_FL_STREAM_START);
out:
if (ret < 0)
ods_obex_transfer_close (obex_context);
else
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
return ret;
}
static gint
ods_obex_put_full (OdsObexContext *obex_context,
const gchar *local, const gchar *remote,
const gchar *type, const gchar *img_description,
const gchar *img_handle, const guchar *apparam,
guint apparam_len, guint64 size, time_t mtime,
gboolean is_fifo, gint fifo_fd)
{
gint ret;
obex_headerdata_t hv;
obex_object_t *object = NULL;
gchar *uname = NULL;
gsize uname_len = 0;
gchar *uhandle = NULL;
gsize uhandle_len = 0;
off_t object_size = 0;
time_t object_time = -1;
g_assert (remote || type);
ods_obex_transfer_new (obex_context, local, remote, type);
obex_context->img_handle = g_strdup (img_handle);
/* get UTF16 name for remote file */
if (remote) {
uname_len = ods_filename_to_utf16 (&uname, remote);
if (uname == NULL) {
ret = -EINVAL;
goto out;
}
}
/* get UTF16 version of img_handle */
if (img_handle) {
uhandle_len = ods_filename_to_utf16 (&uhandle, img_handle);
if (uhandle == NULL) {
ret = -EINVAL;
goto out;
}
}
/* open local file, allocate buffer */
if (local) {
int oflags = O_RDONLY;
if (is_fifo)
oflags |= O_NONBLOCK;
if (is_fifo && fifo_fd > -1)
obex_context->stream_fd = fifo_fd;
else
obex_context->stream_fd = open (local, oflags);
if (obex_context->stream_fd < 0) {
ret = -errno;
goto out;
}
if (is_fifo) {
GIOChannel *chan;
/* Setup IO watch to know when it is possible to write to FIFO or error happens */
chan = g_io_channel_unix_new (obex_context->stream_fd);
obex_context->fifo_watch = g_io_add_watch (chan,
G_IO_IN | G_IO_ERR | G_IO_HUP | G_IO_NVAL,
fifo_watch, obex_context);
g_io_channel_unref (chan);
}
/* Allocate buffer */
obex_context->buf = g_malloc (obex_context->tx_max);
obex_context->buf_size = obex_context->tx_max;
} else {
obex_context->report_progress = FALSE;
}
object = OBEX_ObjectNew (obex_context->obex_handle, OBEX_CMD_PUT);
if (!object) {
ret = -ENOMEM;
goto out;
}
/* Add connection header */
if (obex_context->connection_id != CONID_INVALID) {
hv.bq4 = obex_context->connection_id;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hv, 4, 0);
if (ret < 0)
goto out;
}
/* Add name header */
if (uname) {
hv.bs = (guchar *) uname;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_NAME, hv, uname_len, 0);
if (ret < 0)
goto out;
}
/* Add type header */
if (type) {
hv.bs = (guchar *)type;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_TYPE, hv, strlen(type) + 1, 0);
if (ret < 0)
goto out;
}
/* Try to figure out modification time and size */
if (obex_context->stream_fd >= 0 && !img_handle && !img_description) {
/* we don't send TIME and LENGTH headers for BIP functions */
if (is_fifo) {
/* if this is FIFO, we use supplied size and time instead of stat */
object_size = size;
object_time = mtime;
} else {
struct stat stats;
if (fstat (obex_context->stream_fd, &stats) == 0) {
object_size = stats.st_size;
object_time = stats.st_mtime;
}
}
obex_context->modtime = object_time;
}
/* Add a time header */
if (object_time != -1) {
gchar tstr[17];
gint len;
len = ods_make_iso8601 (object_time, tstr, sizeof (tstr));
if (len >= 0) {
hv.bs = (guchar *)tstr;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_TIME, hv, len, 0);
if (ret < 0)
goto out;
}
}
/* Add a length header */
if (object_size > 0) {
obex_context->target_size = object_size;
hv.bq4 = (uint32_t)object_size;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_LENGTH, hv, 4, 0);
if (ret < 0)
goto out;
} else {
/* set target_size without sending length header (for BIP) */
obex_context->target_size = size;
}
/* Add Img-Description header */
if (img_description) {
hv.bs = (guchar *)img_description;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_IMG_DESCRIPTOR, hv,
strlen (img_description), 0);
if (ret < 0)
goto out;
}
/* Add Img-Handle header */
if (uhandle) {
hv.bs = (guchar *)uhandle;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_IMG_HANDLE, hv,
uhandle_len, 0);
if (ret < 0)
goto out;
}
/* Add Application-Parameters header */
if (apparam) {
hv.bs = apparam;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_APPARAM, hv,
apparam_len, 0);
if (ret < 0)
goto out;
}
/* Add body header */
if (obex_context->stream_fd >= 0) {
hv.bs = NULL;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_BODY, hv, 0, OBEX_FL_STREAM_START);
if (ret < 0)
goto out;
}
ret = ods_obex_send (obex_context, object);
out:
if (uname_len > 0)
g_free (uname);
if (uhandle_len > 0)
g_free (uhandle);
if (ret < 0 && object)
OBEX_ObjectDelete (obex_context->obex_handle, object);
if (ret < 0)
ods_obex_transfer_close (obex_context);
return ret;
}
gint
ods_obex_put (OdsObexContext *obex_context,
const gchar *local, const gchar *remote,
const gchar *type, guint64 size, time_t mtime,
gboolean is_fifo, gint fifo_fd)
{
return ods_obex_put_full (obex_context, local, remote, type,
NULL, NULL, NULL, 0, size, mtime,
is_fifo, fifo_fd);
}
static void
ods_obex_srv_put_image (OdsObexContext *obex_context,
const gchar *img_descriptor)
{
gchar *encoding = NULL;
gchar *pixel = NULL;
guint64 size = 0;
gchar *transformation = NULL;
parse_image_descriptor (img_descriptor, &encoding, &pixel, &size,
&transformation);
obex_context->target_size = size;
if (encoding)
ods_obex_transfer_add_info (obex_context, "Encoding", encoding);
if (pixel)
ods_obex_transfer_add_info (obex_context, "Pixel", pixel);
if (transformation)
ods_obex_transfer_add_info (obex_context, "Transformation", transformation);
}
static void
ods_obex_srv_put_linked_thumbnail (OdsObexContext *obex_context)
{
/* make remote filename the same as image handle */
obex_context->remote = g_strdup (obex_context->img_handle);
}
static void
ods_obex_srv_put_linked_attachment (OdsObexContext *obex_context,
const gchar *img_descriptor)
{
gchar *name = NULL;
guint64 size = 0;
gchar *content_type = NULL;
gchar *charset = NULL;
gchar *created = NULL;
parse_attachment_descriptor (img_descriptor, &name, &size, &content_type,
&charset, &created);
if (!name)
name = g_strdup (ATTACHMENT_FILENAME);
obex_context->remote = name;
obex_context->target_size = size;
if (content_type)
ods_obex_transfer_add_info (obex_context, "ContentType", content_type);
if (charset)
ods_obex_transfer_add_info (obex_context, "Charset", charset);
if (created)
ods_obex_transfer_add_info (obex_context, "Created", created);
}
static gboolean
ods_obex_srv_remote_display (OdsObexContext *obex_context,
guchar *apparam, guint apparam_len, guint8 *action)
{
bip_apparam_remote_display_t *apparam_hdr;
g_assert (action);
if (apparam_len != sizeof (bip_apparam_remote_display_t)) {
/* Invalid application parameters header */
return FALSE;
}
apparam_hdr = (bip_apparam_remote_display_t*) apparam;
if (apparam_hdr->tag_id != BIP_APPARAM_REMOTEDISPLAY_TAGID) {
/* Invalid TagID */
return FALSE;
}
*action = apparam_hdr->value;
return TRUE;
}
gint
ods_obex_srv_put (OdsObexContext *obex_context, obex_object_t *object,
const gchar *path, guint8 *action, gboolean no_response_on_success)
{
obex_headerdata_t hv;
uint8_t hi;
guint hlen;
gint ret = 0;
guint written = 0;
gint write_ret;
gboolean is_delete = TRUE;
gchar *img_descriptor = NULL;
guchar *apparam = NULL;
guint apparam_len = 0;
while (OBEX_ObjectGetNextHeader(obex_context->obex_handle, object,
&hi, &hv, &hlen)) {
g_message ("header: %d", hi);
switch (hi) {
case OBEX_HDR_BODY:
is_delete = FALSE;
g_message ("HDR_BODY length=%u", hlen);
break;
case OBEX_HDR_NAME:
obex_context->remote = ods_filename_from_utf16 ((gchar *) hv.bs, hlen);
g_message ("HDR_NAME: %s", obex_context->remote);
break;
case OBEX_HDR_TYPE:
if (hv.bs[hlen - 1] != '\0' ||
!g_utf8_validate ((const gchar *) hv.bs, -1, NULL)) {
/* invalid type header */
g_message ("HDR_TYPE invalid: %s", (gchar*) hv.bs);
}
else {
obex_context->type = g_strdup ((const gchar *) hv.bs);
is_delete = FALSE;
g_message ("HDR_TYPE: %s", obex_context->type);
}
break;
case OBEX_HDR_LENGTH:
obex_context->target_size = hv.bq4;
is_delete = FALSE;
g_message ("HDR_LENGTH: %" G_GUINT64_FORMAT, obex_context->target_size);
break;
case OBEX_HDR_TIME:
obex_context->modtime = ods_parse_iso8601 ((gchar*) hv.bs, hlen);
g_message ("HDR_TIME");
break;
case OBEX_HDR_DESCRIPTION:
/* Not very useful info */
break;
case OBEX_HDR_COUNT:
/* This informs us how many objects client is going to send
* during this session. We really don't care. */
break;
case OBEX_HDR_CONNECTION:
if (obex_context->connection_id != CONID_INVALID &&
hv.bq4 != obex_context->connection_id) {
/* wrong connection id */
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_BAD_REQUEST, OBEX_RSP_BAD_REQUEST);
goto out;
}
break;
case OBEX_HDR_IMG_DESCRIPTOR:
/* BIP-specific Img-Description header */
img_descriptor = g_malloc0 (hlen+1);/* allocate one more byte for terminating \0 */
memcpy (img_descriptor, hv.bs, hlen);
break;
case OBEX_HDR_IMG_HANDLE:
/* BIP-specific Img-Handle header */
obex_context->img_handle = ods_filename_from_utf16 ((gchar *) hv.bs, hlen);
g_message ("HDR_IMG_HANDLE: %s", obex_context->img_handle);
break;
case OBEX_HDR_APPARAM:
/* application parameters header */
apparam_len = hlen;
apparam = g_malloc (apparam_len);
memcpy (apparam, hv.bs, apparam_len);
break;
default:
break;
}
}
OBEX_ObjectReParseHeaders (obex_context->obex_handle, object);
/* Call helper functions to deal with specific data */
if (obex_context->connection_id != CONID_INVALID && obex_context->type) {
if (!g_ascii_strncasecmp (obex_context->type, BIP_IMG_TYPE,
strlen (obex_context->type))) {
/* PutImage was requested */
ods_obex_srv_put_image (obex_context, img_descriptor);
} else if (!g_ascii_strncasecmp (obex_context->type, BIP_THM_TYPE,
strlen (obex_context->type))) {
/* PutLinkedThumbnail was requested */
ods_obex_srv_put_linked_thumbnail (obex_context);
} else if (!g_ascii_strncasecmp (obex_context->type, BIP_ATTACHMENT_TYPE,
strlen (obex_context->type))) {
/* PutLinkedAttachment was requested */
ods_obex_srv_put_linked_attachment (obex_context, img_descriptor);
} else if (!g_ascii_strncasecmp (obex_context->type, BIP_DISPLAY_TYPE,
strlen (obex_context->type))) {
/* RemoteDisplay was requested */
if (!ods_obex_srv_remote_display (obex_context, apparam,
apparam_len, action)) {
obex_context->report_progress = FALSE;
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_BAD_REQUEST, OBEX_RSP_BAD_REQUEST);
goto out;
}
}
}
g_message ("path: %s", path);
/* Open file for writing only if this is not a delete request */
if (!is_delete) {
if (!ods_obex_srv_new_file (obex_context, path)) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED, OBEX_RSP_UNAUTHORIZED);
goto out;
}
} else {
/* this is a delete request */
obex_context->report_progress = FALSE;
obex_context->local = g_build_filename (path, obex_context->remote, NULL);
if (!g_file_test (obex_context->local, G_FILE_TEST_EXISTS)) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
goto out;
}
if (g_access (obex_context->local, W_OK) < 0) {
ret = -1;
OBEX_ObjectSetRsp (object, OBEX_RSP_UNAUTHORIZED, OBEX_RSP_UNAUTHORIZED);
goto out;
}
g_message ("Deleting: %s", obex_context->local);
if (g_file_test (obex_context->local, G_FILE_TEST_IS_DIR))
ret = rmdir (obex_context->local);
else
ret = g_unlink (obex_context->local);
if (ret == -1)
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
}
/* If there is some data received already, write it to file */
while (written < obex_context->buf_size) {
write_ret = write (obex_context->stream_fd, obex_context->buf + written,
obex_context->buf_size - written);
if (write_ret < 0 && errno == EINTR)
continue;
if (write_ret < 0) {
ret = -errno;
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
break;
}
written += write_ret;
}
out:
g_free (img_descriptor);
g_free (apparam);
if (ret < 0)
ods_obex_transfer_close (obex_context);
else
if (!no_response_on_success)
OBEX_ObjectSetRsp (object, OBEX_RSP_CONTINUE, OBEX_RSP_SUCCESS);
return ret;
}
gint
ods_obex_setpath (OdsObexContext *obex_context, const gchar *path,
gboolean create)
{
gint ret;
obex_headerdata_t hv;
obex_object_t *object = NULL;
obex_setpath_hdr_t nonhdrdata;
gchar *uname;
gsize uname_len;
nonhdrdata.flags = 0x02;
nonhdrdata.constants = 0;
if (strcmp (path, "..") == 0) {
/* move up one directory */
nonhdrdata.flags = 0x03;
uname_len = 0;
} else {
/* normal directory change */
uname_len = ods_filename_to_utf16 (&uname, path);
if (uname == NULL) {
ret = -EINVAL;
goto out;
}
}
/* Add create flag */
if (create)
nonhdrdata.flags &= ~0x02;
object = OBEX_ObjectNew (obex_context->obex_handle, OBEX_CMD_SETPATH);
if (!object) {
ret = -ENOMEM;
goto out;
}
/* Attach flags */
ret = OBEX_ObjectSetNonHdrData (object, (uint8_t*)&nonhdrdata, 2);
if (ret < 0)
goto out;
/* Add connection header */
if (obex_context->connection_id != CONID_INVALID) {
hv.bq4 = obex_context->connection_id;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hv, 4, 0);
if (ret < 0)
goto out;
}
/* Add name header */
hv.bs = (guchar *) uname;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_NAME, hv, uname_len, 0);
if (ret < 0)
goto out;
ret = ods_obex_send (obex_context, object);
out:
if (uname_len > 0 )
g_free (uname);
if (ret < 0 && object)
OBEX_ObjectDelete (obex_context->obex_handle, object);
return ret;
}
gboolean
ods_obex_srv_setpath (OdsObexContext *obex_context, obex_object_t *object,
const gchar *root_path, const gchar *current_path,
gchar **new_path, gboolean allow_write)
{
uint8_t *nonhdrdata_dummy = NULL;
obex_setpath_hdr_t *nonhdrdata;
obex_headerdata_t hv;
uint8_t hi;
guint hlen;
gchar *directory = NULL;
gboolean create = FALSE;
gboolean backup = FALSE;
gboolean ret = FALSE;
OBEX_ObjectGetNonHdrData (object, &nonhdrdata_dummy);
if (!nonhdrdata_dummy) {
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
return FALSE;
}
nonhdrdata = (obex_setpath_hdr_t*) nonhdrdata_dummy;
if (nonhdrdata->flags == 0)
create = TRUE;
else if (nonhdrdata->flags == 0x03)
backup = TRUE;
else if (nonhdrdata->flags != 0x02) {
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
return FALSE;
}
if (backup) {
/* we have to go to parent directory */
/* Check if we can't go up */
if (strcmp (root_path, current_path) == 0) {
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND, OBEX_RSP_NOT_FOUND);
return FALSE;
}
*new_path = g_path_get_dirname (current_path);
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
return TRUE;
}
/* set default response to Forbidden (in case we fail to parse the headers correctly) */
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN, OBEX_RSP_FORBIDDEN);
while (OBEX_ObjectGetNextHeader (obex_context->obex_handle, object,
&hi, &hv, &hlen)) {
if (hi == OBEX_HDR_NAME) {
if (hlen > 0) {
/* Normal directory change */
directory = ods_filename_from_utf16 ((gchar *) hv.bs, hlen);
*new_path = g_build_filename (current_path, directory, NULL);
/* Check if such path exists */
if (g_file_test (*new_path, G_FILE_TEST_EXISTS)) {
if (create) {
g_free (*new_path);
*new_path = ods_obex_get_new_path (current_path,
directory);
} else {
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS,
OBEX_RSP_SUCCESS);
ret = TRUE;
goto out;
}
} else if (!create) {
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_FOUND,
OBEX_RSP_NOT_FOUND);
ret = FALSE;
goto out;
}
/* In case we are Creating new folder */
if (allow_write && mkdir (*new_path, 0755) == 0) {
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS,
OBEX_RSP_SUCCESS);
ret = TRUE;
goto out;
}
OBEX_ObjectSetRsp (object, OBEX_RSP_FORBIDDEN,
OBEX_RSP_FORBIDDEN);
ret = FALSE;
goto out;
} else {
/* Name header empty, change path to root */
*new_path = g_strdup (root_path);
OBEX_ObjectSetRsp (object, OBEX_RSP_SUCCESS, OBEX_RSP_SUCCESS);
ret = TRUE;
goto out;
}
}
}
out:
if (directory)
g_free (directory);
if (!ret && *new_path) {
g_free (*new_path);
*new_path = NULL;
}
return ret;
}
gint
ods_obex_put_image (OdsObexContext *obex_context,
const gchar *local, const gchar *remote,
const gchar *encoding, const gchar *pixel,
guint64 size, const gchar *transformation)
{
gchar *img_descriptor;
gint ret;
g_assert (local && remote && encoding && pixel && transformation);
img_descriptor = get_image_descriptor (encoding, pixel, size, transformation);
ret = ods_obex_put_full (obex_context, local, remote, BIP_IMG_TYPE,
img_descriptor, NULL, NULL, 0, size, -1, FALSE, -1);
if (*encoding != '\0')
ods_obex_transfer_add_info (obex_context, "Encoding",
g_strdup (encoding));
if (*pixel != '\0')
ods_obex_transfer_add_info (obex_context, "Pixel", g_strdup (pixel));
if (*transformation != '\0')
ods_obex_transfer_add_info (obex_context, "Transformation",
g_strdup (transformation));
g_free (img_descriptor);
return ret;
}
gint
ods_obex_put_linked_thumbnail (OdsObexContext *obex_context,
const gchar *local, const gchar *img_handle,
guint64 size)
{
g_assert (local && img_handle);
return ods_obex_put_full (obex_context, local, NULL, BIP_THM_TYPE,
NULL, img_handle, NULL, 0, size, -1, FALSE, -1);
}
gint
ods_obex_put_linked_attachment (OdsObexContext *obex_context,
const gchar *local, const gchar *img_handle,
const gchar *name, const gchar *content_type,
const gchar *charset, guint64 size, time_t ctime)
{
gchar *att_descriptor;
gint ret;
struct stat stats;
guint64 object_size = 0;
time_t object_ctime = -1;
gchar created_time[17];
g_assert (local && img_handle && name && content_type && charset);
if (size > 0) {
object_size = size;
object_ctime = ctime;
} else if (g_stat (local, &stats) == 0) {
object_size = stats.st_size;
object_ctime = stats.st_ctime;
}
if (object_ctime != -1)
ods_make_iso8601 (ctime, created_time, sizeof (created_time));
att_descriptor = get_attachment_descriptor(name, object_size, content_type, charset,
object_ctime!=-1 ? created_time : "");
ret = ods_obex_put_full (obex_context, local, NULL, BIP_ATTACHMENT_TYPE,
att_descriptor, img_handle, NULL, 0, object_size,
-1, FALSE, -1);
obex_context->remote = g_strdup (name);/* set it here so that we don't send NAME header*/
if (*content_type != '\0')
ods_obex_transfer_add_info (obex_context, "ContentType",
g_strdup (content_type));
if (*charset != '\0')
ods_obex_transfer_add_info (obex_context, "Charset", g_strdup (charset));
if (ctime != -1)
ods_obex_transfer_add_info (obex_context, "Created",
g_strdup (created_time));
g_free (att_descriptor);
return ret;
}
/* img_handle must not be NULL, must be empty when action != SelectImage */
gint
ods_obex_remote_display (OdsObexContext *obex_context,
const gchar *img_handle, guint8 action)
{
bip_apparam_remote_display_t *apparam_hdr;
gint ret;
g_assert (img_handle);
apparam_hdr = g_new0 (bip_apparam_remote_display_t, 1);
apparam_hdr->tag_id = BIP_APPARAM_REMOTEDISPLAY_TAGID;
apparam_hdr->length = 1;
apparam_hdr->value = action;
ret = ods_obex_put_full (obex_context, NULL, NULL, BIP_DISPLAY_TYPE,
NULL, img_handle, (guchar *) apparam_hdr,
sizeof (bip_apparam_remote_display_t), 0,
-1, FALSE, -1);
g_free (apparam_hdr);
return ret;
}
gint
ods_obex_action (OdsObexContext *obex_context, const gchar *src,
const gchar *dst, guint8 action, guint32 perms)
{
gint ret;
obex_object_t *object;
obex_headerdata_t hv;
gchar *uname;
gsize uname_len;
if (action != OBEX_ACTION_SETPERM)
g_assert (src && dst);
object = OBEX_ObjectNew (obex_context->obex_handle, OBEX_CMD_ACTION);
/* Add connection header */
if (obex_context->connection_id != CONID_INVALID) {
hv.bq4 = obex_context->connection_id;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_CONNECTION, hv, 4, 0);
if (ret < 0)
goto out;
}
/* src header */
uname_len = ods_filename_to_utf16 (&uname, src);
if (uname == NULL) {
ret = -EINVAL;
goto out;
}
hv.bs = (guchar *) uname;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_NAME, hv, uname_len, 0);
g_free (uname);
if (ret < 0)
goto out;
/* dst header */
uname_len = ods_filename_to_utf16 (&uname, dst);
if (uname == NULL) {
ret = -EINVAL;
goto out;
}
hv.bs = (guchar *) uname;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_DESTNAME, hv, uname_len, 0);
g_free (uname);
if (ret < 0)
goto out;
/* action header */
hv.bq1 = action;
OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_ACTION_ID, hv, 1, 0);
/* permissions header */
if (action == OBEX_ACTION_SETPERM) {
hv.bq4 = perms;
ret = OBEX_ObjectAddHeader (obex_context->obex_handle, object,
OBEX_HDR_PERMISSIONS, hv, 4, 0);
if (ret < 0)
goto out;
}
ret = ods_obex_send (obex_context, object);
out:
if (ret < 0 && object)
OBEX_ObjectDelete (obex_context->obex_handle, object);
return ret;
}
obex-data-server-0.4.6/src/ods-error.c 0000644 0001750 0001750 00000015130 11524724173 014467 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include "ods-error.h"
/**
* ods_error_quark:
* Return value: Our personal error quark.
**/
GQuark
ods_error_quark (void)
{
static GQuark quark = 0;
if (!quark) {
quark = g_quark_from_static_string ("ods_error");
}
return quark;
}
/**
* ods_error_get_type:
**/
#define ENUM_ENTRY(NAME, DESC) { NAME, "" #NAME "", DESC }
GType
ods_error_get_type (void)
{
static GType etype = 0;
if (etype == 0) {
static const GEnumValue values[] = {
ENUM_ENTRY (ODS_ERROR_INVALID_ARGUMENTS, "InvalidArguments"),
ENUM_ENTRY (ODS_ERROR_CONNECTION_ATTEMPT_FAILED, "ConnectionAttemptFailed"),
ENUM_ENTRY (ODS_ERROR_NOT_SUPPORTED, "NotSupported"),
ENUM_ENTRY (ODS_ERROR_NOT_FOUND, "NotFound"),
ENUM_ENTRY (ODS_ERROR_BUSY, "Busy"),
ENUM_ENTRY (ODS_ERROR_NOT_AUTHORIZED, "NotAuthorized"),
ENUM_ENTRY (ODS_ERROR_OUT_OF_MEMORY, "OutOfMemory"),
ENUM_ENTRY (ODS_ERROR_FAILED, "Failed"), /* generic error */
ENUM_ENTRY (ODS_ERROR_NOT_CONNECTED, "NotConnected"),
ENUM_ENTRY (ODS_ERROR_FORBIDDEN, "Forbidden"),
ENUM_ENTRY (ODS_ERROR_LINK_ERROR, "LinkError"),
ENUM_ENTRY (ODS_ERROR_BAD_DATA, "BadData"),
ENUM_ENTRY (ODS_ERROR_STARTED, "Started"),
ENUM_ENTRY (ODS_ERROR_NOT_STARTED, "NotStarted"),
ENUM_ENTRY (ODS_ERROR_TRANSPORT_NOT_AVAILABLE, "TransportNotAvailable"),
ENUM_ENTRY (ODS_ERROR_CONNECTION_REFUSED, "ConnectionRefused"),
ENUM_ENTRY (ODS_ERROR_CONNECTION_TIMEOUT, "ConnectionTimeout"),
ENUM_ENTRY (ODS_ERROR_BAD_REQUEST, "BadRequest"),
ENUM_ENTRY (ODS_ERROR_NOT_IMPLEMENTED, "NotImplemented"),
ENUM_ENTRY (ODS_ERROR_SERVER_ERROR, "ServerError"),
ENUM_ENTRY (ODS_ERROR_TIMEOUT, "Timeout"),
ENUM_ENTRY (ODS_ERROR_CANCELLED, "Cancelled"),
ENUM_ENTRY (ODS_ERROR_NOT_MODIFIED, "NotModified"),
ENUM_ENTRY (ODS_ERROR_DATABASE_ERROR, "DatabaseError"),
ENUM_ENTRY (ODS_ERROR_CONFLICT, "Conflict"),
ENUM_ENTRY (ODS_ERROR_UNSUPPORTED_MEDIA_TYPE, "UnsupportedMediaType"),
ENUM_ENTRY (ODS_ERROR_NO_FIFO_READER, "NoFifoReader"),
{ 0, 0, 0 }
};
etype = g_enum_register_static ("OdsError", values);
}
return etype;
}
void
ods_error_err2gerror (gint err, GError **error)
{
if (!error)
return;
if (err < 0)
err = -err;
switch (err) {
case EACCES:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_AUTHORIZED,
"Permission denied");
break;
case EBUSY:
g_set_error (error, ODS_ERROR, ODS_ERROR_BUSY,
"Another operation in progress");
break;
case EINVAL:
g_set_error (error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid arguments");
break;
case ENOENT:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_FOUND,
"File not found");
break;
case ENOMEM:
g_set_error (error, ODS_ERROR, ODS_ERROR_OUT_OF_MEMORY,
"Out of memory");
break;
case EPERM:
g_set_error (error, ODS_ERROR, ODS_ERROR_FORBIDDEN,
"Operation forbidden");
break;
case ENOSPC:
g_set_error (error, ODS_ERROR, ODS_ERROR_DATABASE_ERROR,
"No space left on device");
break;
case ENXIO:
g_set_error (error, ODS_ERROR, ODS_ERROR_NO_FIFO_READER,
"No process has opened supplied FIFO for reading");
break;
default:
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED,
"Unknown error occurred (errno: %d)", err);
break;
}
}
void
ods_error_obexrsp2gerror (gint obex_response, GError **error)
{
if (!error)
return;
switch (obex_response) {
case OBEX_RSP_REQUEST_TIME_OUT:
g_set_error (error, ODS_ERROR, ODS_ERROR_TIMEOUT,
"Request timeout");
break;
case OBEX_RSP_BAD_REQUEST:
g_set_error (error, ODS_ERROR, ODS_ERROR_BAD_REQUEST,
"Bad request");
break;
case OBEX_RSP_FORBIDDEN:
g_set_error (error, ODS_ERROR, ODS_ERROR_FORBIDDEN,
"Operation forbidden");
break;
case OBEX_RSP_NOT_FOUND:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_FOUND,
"File not found");
break;
case OBEX_RSP_NOT_IMPLEMENTED:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_IMPLEMENTED,
"Not implemented");
break;
case OBEX_RSP_UNAUTHORIZED:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_AUTHORIZED,
"Not authorized");
break;
case OBEX_RSP_INTERNAL_SERVER_ERROR:
g_set_error (error, ODS_ERROR, ODS_ERROR_SERVER_ERROR,
"Remote server error");
break;
case OBEX_RSP_NOT_MODIFIED:
g_set_error (error, ODS_ERROR, ODS_ERROR_NOT_MODIFIED,
"No modification done");
break;
case OBEX_RSP_CONFLICT:
g_set_error (error, ODS_ERROR, ODS_ERROR_CONFLICT,
"Conflict error");
break;
case OBEX_RSP_DATABASE_FULL:
g_set_error (error, ODS_ERROR, ODS_ERROR_DATABASE_ERROR,
"Could not write (database full)");
break;
case OBEX_RSP_DATABASE_LOCKED:
g_set_error (error, ODS_ERROR, ODS_ERROR_DATABASE_ERROR,
"Could not read/write (database locked)");
break;
case OBEX_RSP_UNSUPPORTED_MEDIA_TYPE:
g_set_error (error, ODS_ERROR, ODS_ERROR_UNSUPPORTED_MEDIA_TYPE,
"Media type not supported");
break;
default:
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED,
"Operation failed (unexpected response)");
break;
}
}
gchar *
ods_error_get_dbus_name (GError *error)
{
GEnumClass *klass;
GEnumValue *value;
const gchar *error_name;
klass = g_type_class_ref (ods_error_get_type ());
value = g_enum_get_value (klass, error->code);
g_type_class_unref (klass);
error_name = value->value_nick;
return g_strdup_printf ("%s.%s", ODS_ERROR_DBUS_INTERFACE, error_name);
}
obex-data-server-0.4.6/src/ods-usb.c 0000644 0001750 0001750 00000031454 11524724173 014136 0000000 0000000 #include "config.h"
#ifdef USE_USB
#include
#include /* perror */
#include /* errno and EADDRNOTAVAIL */
#include
#include
#include "ods-usb.h"
struct ods_usb_intf_transport_t {
struct ods_usb_intf_transport_t *prev, *next; /* Next and previous interfaces in the list */
struct usb_device *device; /* USB device that has the interface */
int configuration; /* Device configuration */
int configuration_description; /* Configuration string descriptor number */
int control_interface; /* OBEX master interface */
int control_setting; /* OBEX master interface setting */
int control_interface_description; /* OBEX master interface string descriptor number
* If non-zero, use usb_get_string_simple() from
* libusb to retrieve human-readable description
*/
unsigned char *extra_descriptors; /* Extra master interface descriptors */
int extra_descriptors_len; /* Length of extra descriptors */
int data_interface; /* OBEX data/slave interface */
int data_idle_setting; /* OBEX data/slave idle setting */
int data_interface_idle_description; /* OBEX data/slave interface string descriptor number
* in idle setting */
int data_active_setting; /* OBEX data/slave active setting */
int data_interface_active_description; /* OBEX data/slave interface string descriptor number
* in active setting */
int data_endpoint_read; /* OBEX data/slave interface read endpoint */
int data_endpoint_write; /* OBEX data/slave interface write endpoint */
usb_dev_handle *dev_control; /* libusb handler for control interace */
usb_dev_handle *dev_data; /* libusb handler for data interface */
char *path; /* Path, see path in obex_usb_intf_t */
};
/* "Union Functional Descriptor" from CDC spec 5.2.3.X
* used to find data/slave OBEX interface */
#pragma pack(1)
struct cdc_union_desc {
guint8 bLength;
guint8 bDescriptorType;
guint8 bDescriptorSubType;
guint8 bMasterInterface0;
guint8 bSlaveInterface0;
};
#pragma pack()
/* CDC class and subclass types */
#define USB_CDC_CLASS 0x02
#define USB_CDC_OBEX_SUBCLASS 0x0b
/* class and subclass specific descriptor types */
#define CDC_HEADER_TYPE 0x00
#define CDC_CALL_MANAGEMENT_TYPE 0x01
#define CDC_AC_MANAGEMENT_TYPE 0x02
#define CDC_UNION_TYPE 0x06
#define CDC_COUNTRY_TYPE 0x07
#define CDC_OBEX_TYPE 0x15
#define CDC_OBEX_SERVICE_ID_TYPE 0x19
/* Interface descriptor */
#define USB_DT_CS_INTERFACE 0x24
#define CDC_DATA_INTERFACE_TYPE 0x0a
#define WMC_DEFAULT_OBEX_SERVER_UUID \
{ 0x02, 0xae, 0xb3, 0x20, \
0xf6, 0x49, 0x11, 0xda, \
0x97, 0x4d, 0x08, 0x00, \
0x20, 0x0c, 0x9a, 0x66 }
#define USB_MAX_STRING_SIZE 256
#define USB_OBEX_TIMEOUT 10000 /* 10 seconds */
/*
* Helper function to usbobex_find_interfaces
*/
static void find_eps(struct ods_usb_intf_transport_t *intf, struct usb_interface_descriptor data_intf, int *found_active, int *found_idle)
{
struct usb_endpoint_descriptor *ep0, *ep1;
if (data_intf.bNumEndpoints == 2) {
ep0 = data_intf.endpoint;
ep1 = data_intf.endpoint + 1;
if ((ep0->bEndpointAddress & USB_ENDPOINT_IN) &&
((ep0->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK) &&
!(ep1->bEndpointAddress & USB_ENDPOINT_IN) &&
((ep1->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK)) {
*found_active = 1;
intf->data_active_setting = data_intf.bAlternateSetting;
intf->data_interface_active_description = data_intf.iInterface;
intf->data_endpoint_read = ep0->bEndpointAddress;
intf->data_endpoint_write = ep1->bEndpointAddress;
}
if (!(ep0->bEndpointAddress & USB_ENDPOINT_IN) &&
((ep0->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK) &&
(ep1->bEndpointAddress & USB_ENDPOINT_IN) &&
((ep1->bmAttributes & USB_ENDPOINT_TYPE_MASK) == USB_ENDPOINT_TYPE_BULK)) {
*found_active = 1;
intf->data_active_setting = data_intf.bAlternateSetting;
intf->data_interface_active_description = data_intf.iInterface;
intf->data_endpoint_read = ep1->bEndpointAddress;
intf->data_endpoint_write = ep0->bEndpointAddress;
}
}
if (data_intf.bNumEndpoints == 0) {
*found_idle = 1;
intf->data_idle_setting = data_intf.bAlternateSetting;
intf->data_interface_idle_description = data_intf.iInterface;
}
}
/*
* Helper function to usbobex_find_interfaces
*/
static int find_obex_data_interface(unsigned char *buffer, int buflen, struct usb_config_descriptor config, struct ods_usb_intf_transport_t *intf)
{
struct cdc_union_desc *union_header = NULL;
int i, a;
int found_active = 0;
int found_idle = 0;
if (!buffer) {
g_debug("Weird descriptor references");
return -EINVAL;
}
while (buflen > 0) {
if (buffer [1] != USB_DT_CS_INTERFACE) {
g_debug("skipping garbage");
goto next_desc;
}
switch (buffer [2]) {
case CDC_UNION_TYPE: /* we've found it */
if (union_header) {
g_debug("More than one union descriptor, skiping ...");
goto next_desc;
}
union_header = (struct cdc_union_desc *)buffer;
break;
case CDC_OBEX_TYPE: /* maybe check version */
case CDC_OBEX_SERVICE_ID_TYPE: /* This one is handled later */
case CDC_HEADER_TYPE:
break; /* for now we ignore it */
default:
g_debug("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
break;
}
next_desc:
buflen -= buffer[0];
buffer += buffer[0];
}
if (!union_header) {
g_debug("No union descriptor, giving up");
return -ENODEV;
}
/* Found the slave interface, now find active/idle settings and endpoints */
intf->data_interface = union_header->bSlaveInterface0;
/* Loop through all of the interfaces */
for (i = 0; i < config.bNumInterfaces; i++) {
/* Loop through all of the alternate settings */
for (a = 0; a < config.interface[i].num_altsetting; a++) {
/* Check if this interface is OBEX data interface*/
/* and find endpoints */
if (config.interface[i].altsetting[a].bInterfaceNumber == intf->data_interface)
find_eps(intf, config.interface[i].altsetting[a], &found_active, &found_idle);
}
}
if (!found_idle) {
g_debug("No idle setting");
return -ENODEV;
}
if (!found_active) {
g_debug("No active setting");
return -ENODEV;
}
return 0;
}
/*
* Helper function to usbobex_find_interfaces
*/
static int get_intf_string(struct usb_dev_handle *usb_handle, char **string, int id)
{
if (id) {
if ((*string = malloc(USB_MAX_STRING_SIZE)) == NULL)
return -ENOMEM;
*string[0] = '\0';
return usb_get_string_simple(usb_handle, id, *string, USB_MAX_STRING_SIZE);
}
return 0;
}
/*
* Helper function to usbobex_find_interfaces
*/
static struct ods_usb_intf_transport_t *check_intf(struct usb_device *dev,
int c, int i, int a,
char *bus, char *device,
struct ods_usb_intf_transport_t *current) {
struct ods_usb_intf_transport_t *next = NULL;
if ((dev->config[c].interface[i].altsetting[a].bInterfaceClass == USB_CDC_CLASS)
&& (dev->config[c].interface[i].altsetting[a].bInterfaceSubClass == USB_CDC_OBEX_SUBCLASS)) {
int err;
unsigned char *buffer = dev->config[c].interface[i].altsetting[a].extra;
int buflen = dev->config[c].interface[i].altsetting[a].extralen;
next = malloc(sizeof(struct ods_usb_intf_transport_t));
if (next == NULL)
return current;
next->device = dev;
next->configuration = dev->config[c].bConfigurationValue;
next->configuration_description = dev->config[c].iConfiguration;
next->control_interface = dev->config[c].interface[i].altsetting[a].bInterfaceNumber;
next->control_interface_description = dev->config[c].interface[i].altsetting[a].iInterface;
next->control_setting = dev->config[c].interface[i].altsetting[a].bAlternateSetting;
next->extra_descriptors = buffer;
next->extra_descriptors_len = buflen;
err = find_obex_data_interface(buffer, buflen, dev->config[c], next);
if (err)
free(next);
else {
char path[200], *s, *shortdev;
/* On MacOS X we might get 002-04a9-3139-00-00 instead of 002 for the dev. */
shortdev = strdup (device);
s = strchr(shortdev, '-');
if (s)
*s='\0';
/* Create the usb: path for the device */
snprintf (path, sizeof(path), "usb:%s,%s,%d", bus, shortdev, dev->config[c].interface[i].altsetting[a].bInterfaceNumber);
free (shortdev);
next->path = strdup (path);
if (current)
current->next = next;
next->prev = current;
next->next = NULL;
current = next;
}
}
return current;
}
/*
* Helper function to usbobex_find_interfaces
*/
static void find_obex_service_descriptor(unsigned char *buffer, int buflen, ods_usb_intf_service_t **service)
{
if (!buffer) {
g_debug("Weird descriptor references");
return ;
}
while (buflen > 0) {
if (buffer[1] != USB_DT_CS_INTERFACE) {
g_debug("skipping garbage");
goto next_desc;
}
switch (buffer[2]) {
case CDC_OBEX_SERVICE_ID_TYPE: /* we've found it */
if (buflen < 22) /* Check descriptor size */
g_debug("Invalid service id descriptor");
else if (*service == NULL) {
*service = malloc(sizeof(ods_usb_intf_service_t));
if (*service != NULL) {
const guint8 default_uuid[16] = WMC_DEFAULT_OBEX_SERVER_UUID;
(*service)->role = buffer[3];
memcpy((*service)->uuid, buffer+4, 16);
(*service)->version = (buffer[20]<<8)|(buffer[21]);
if (memcmp((*service)->uuid, default_uuid, 16) == 0 )
(*service)->is_default_uuid = 1;
else
(*service)->is_default_uuid = 0;
}
}
break;
case CDC_OBEX_TYPE: /* maybe check version */
case CDC_UNION_TYPE:
case CDC_HEADER_TYPE:
break;
default:
g_debug("Ignoring extra header, type %d, length %d", buffer[2], buffer[0]);
break;
}
next_desc:
buflen -= buffer[0];
buffer += buffer[0];
}
}
/*
* Function usbobex_find_interfaces ()
*
* Find available USBOBEX interfaces on the system
*/
GList *ods_usbobex_find_interfaces(void)
{
struct usb_bus *busses;
struct usb_bus *bus;
struct usb_device *dev;
int c, i, a;
struct ods_usb_intf_transport_t *current = NULL;
struct ods_usb_intf_transport_t *tmp = NULL;
struct usb_dev_handle *usb_handle;
GList *list = NULL;
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
for (bus = busses; bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
/* Loop through all of the configurations */
for (c = 0; c < dev->descriptor.bNumConfigurations; c++) {
/* Loop through all of the interfaces */
for (i = 0; i < dev->config[c].bNumInterfaces; i++) {
/* Loop through all of the alternate settings */
for (a = 0; a < dev->config[c].interface[i].num_altsetting; a++) {
/* Check if this interface is OBEX */
/* and find data interface */
current = check_intf(dev, c, i, a, bus->dirname, dev->filename, current);
}
}
}
}
}
/* Rewind the double-linked list */
while (current && current->prev)
current = current->prev;
while (current) {
ods_usb_info *item;
usb_handle = usb_open(current->device);
item = g_new0 (ods_usb_info, 1);
get_intf_string(usb_handle, &item->manufacturer,
current->device->descriptor.iManufacturer);
get_intf_string(usb_handle, &item->product,
current->device->descriptor.iProduct);
get_intf_string(usb_handle, &item->serial,
current->device->descriptor.iSerialNumber);
get_intf_string(usb_handle, &item->configuration,
current->configuration_description);
get_intf_string(usb_handle, &item->control_interface,
current->control_interface_description);
get_intf_string(usb_handle, &item->data_interface_idle,
current->data_interface_idle_description);
get_intf_string(usb_handle, &item->data_interface_active,
current->data_interface_active_description);
item->path = current->path;
find_obex_service_descriptor(current->extra_descriptors,
current->extra_descriptors_len,
&item->service);
usb_close(usb_handle);
current = current->next;
list = g_list_prepend (list, item);
}
list = g_list_reverse (list);
/* Rewind the double-linked list */
while (current && current->prev)
current = current->prev;
while (current) {
tmp = current->next;
free(current);
current = tmp;
}
return list;
}
/*
* Function usbobex_free_interfaces ()
*
* Free the list of discovered USBOBEX interfaces on the system
*/
static void ods_usbobex_free_interface(ods_usb_info *item)
{
free(item->manufacturer);
free(item->product);
free(item->serial);
free(item->configuration);
free(item->control_interface);
free(item->data_interface_idle);
free(item->data_interface_active);
free(item->service);
free(item->path);
free(item);
}
void ods_usbobex_free_interfaces(GList *list)
{
if (list == NULL)
return;
g_list_foreach (list, (GFunc) ods_usbobex_free_interface, NULL);
g_list_free (list);
}
#endif /* USE_USB */
obex-data-server-0.4.6/src/ods-manager.c 0000644 0001750 0001750 00000140153 11524724173 014754 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-bluez.h"
#include "ods-common.h"
#include "ods-error.h"
#include "ods-server.h"
#include "ods-session.h"
#include "ods-marshal.h"
#include "ods-manager.h"
#include "ods-usb.h"
#include "ods-manager-dbus-glue.h"
#define ODS_MANAGER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ODS_TYPE_MANAGER, OdsManagerPrivate))
typedef struct OdsManagerSessionInfo_ {
OdsSession *session;
/* Bluetooth specific */
OdsBluezCancellable *bluetooth_cancel_data;
gchar *bluetooth_target_address;
gchar *bluetooth_source_address;
gint bluetooth_channel;
/* USB specific */
gint usb_interface_number;
/* TTY specific */
gchar *tty_dev;
} OdsManagerSessionInfo;
typedef struct OdsManagerServerInfo_ {
OdsServer *server;
/* Bluetooth specific */
gchar *bluetooth_source_address;
gboolean require_pairing;
guint32 sdp_record_handle;
/* TTY specific */
gchar *tty_dev;
} OdsManagerServerInfo;
typedef struct OdsManagerCreateSessionData_ {
OdsManager *manager;
OdsSession *session;
gchar *tty_dev;
} OdsManagerCreateSessionData;
struct OdsManagerPrivate {
gboolean is_disposing;
gboolean disposed;
gboolean initialized;
/* Session list (DBus path as key and OdsManagerSessionInfo as value) */
GHashTable *session_list;
/* Server list (DBus path as key and OdsManagerServerInfo as value) */
GHashTable *server_list;
DBusGProxy *dbus_proxy;
GHashTable *listened_dbus_names;
GHashTable *removed_dbus_names;
};
enum {
SESSION_CONNECTED,
SESSION_CLOSED,
SESSION_CONNECT_ERROR,
DISPOSED,
LAST_SIGNAL
};
static guint signals [LAST_SIGNAL] = { 0, };
G_DEFINE_TYPE (OdsManager, ods_manager, G_TYPE_OBJECT)
static gboolean ods_manager_session_finalize (gpointer key,
OdsManagerSessionInfo *session_info,
OdsManager *manager);
static gboolean ods_manager_server_finalize (gpointer key,
OdsManagerServerInfo *server_info,
OdsManager *manager);
static void ods_manager_finalize (GObject *object);
static void
ods_manager_listened_names_add (OdsManager *manager, const gchar *dbus_owner,
const gchar *dbus_path)
{
GHashTable *object_list = NULL;
if (!(object_list = g_hash_table_lookup (manager->priv->listened_dbus_names,
dbus_owner))) {
object_list = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
g_hash_table_insert (manager->priv->listened_dbus_names, g_strdup (dbus_owner),
object_list);
}
g_hash_table_insert (object_list, g_strdup (dbus_path), NULL);
}
static void
ods_manager_listened_names_remove (OdsManager *manager, const gchar *dbus_owner,
const gchar *dbus_path)
{
GHashTable *object_list;
g_message ("Removing listened DBUS name %s (object: %s)", dbus_owner, dbus_path);
if ((object_list = g_hash_table_lookup (manager->priv->listened_dbus_names,
dbus_owner))) {
if (dbus_path) {
g_hash_table_remove (object_list, dbus_path);
if (g_hash_table_size (object_list) > 0)
return;
}
}
g_hash_table_remove (manager->priv->listened_dbus_names, dbus_owner);
g_hash_table_remove (manager->priv->removed_dbus_names, dbus_owner);
g_message ("Removed from listened DBUS names list");
if (manager->priv->is_disposing &&
g_hash_table_size (manager->priv->listened_dbus_names) == 0) {
g_message ("Manager disposed");
manager->priv->disposed = TRUE;
g_signal_emit (manager, signals [DISPOSED], 0);
}
}
static void
ods_manager_session_list_add (OdsManager *manager, OdsSession *session,
OdsBluezCancellable *bluetooth_cancel_data,
const gchar *bluetooth_target_address,
const gchar *bluetooth_source_address,
const gint usb_interface_number,
const gchar *tty_dev,
const gchar *dbus_owner,
const gchar *dbus_path)
{
OdsManagerSessionInfo *session_info;
session_info = g_new0 (OdsManagerSessionInfo, 1);
session_info->session = session;
session_info->bluetooth_cancel_data = bluetooth_cancel_data;
session_info->bluetooth_target_address = g_strdup (bluetooth_target_address);
session_info->bluetooth_source_address = g_strdup (bluetooth_source_address);
session_info->usb_interface_number = usb_interface_number;
session_info->tty_dev = g_strdup (tty_dev);
g_hash_table_insert (manager->priv->session_list, g_strdup (dbus_path),
session_info);
ods_manager_listened_names_add (manager, dbus_owner, dbus_path);
}
static void
ods_manager_server_list_add (OdsManager *manager, OdsServer *server,
const gchar *bluetooth_source_address,
gboolean require_pairing,
guint32 sdp_record_handle,
const gchar *tty_dev,
const gchar *dbus_owner,
const gchar *dbus_path)
{
OdsManagerServerInfo *server_info;
server_info = g_new0 (OdsManagerServerInfo, 1);
server_info->server = server;
server_info->bluetooth_source_address = g_strdup (bluetooth_source_address);
server_info->require_pairing = require_pairing;
server_info->sdp_record_handle = sdp_record_handle;
server_info->tty_dev = g_strdup (tty_dev);
g_hash_table_insert (manager->priv->server_list, g_strdup (dbus_path),
server_info);
ods_manager_listened_names_add (manager, dbus_owner, dbus_path);
}
static void
ods_manager_session_info_free (OdsManagerSessionInfo *session_info)
{
g_free (session_info->bluetooth_target_address);
g_free (session_info->bluetooth_source_address);
g_free (session_info->tty_dev);
g_free (session_info);
}
static void
ods_manager_server_info_free (OdsManagerServerInfo *server_info)
{
g_free (server_info->bluetooth_source_address);
g_free (server_info->tty_dev);
g_free (server_info);
}
static void
ods_manager_session_list_remove (OdsManager *manager, OdsSession *session)
{
gchar *session_object;
gchar *owner;
g_object_get (session, "dbus-path", &session_object, NULL);
g_object_get (session, "owner", &owner, NULL);
if (!manager->priv->is_disposing)
g_hash_table_remove (manager->priv->session_list, session_object);
ods_manager_listened_names_remove (manager, owner, session_object);
g_free (session_object);
g_free (owner);
}
static void
ods_manager_server_list_remove (OdsManager *manager, OdsServer *server)
{
gchar *server_object;
gchar *owner;
g_object_get (server, "dbus-path", &server_object, NULL);
g_object_get (server, "owner", &owner, NULL);
if (!manager->priv->is_disposing)
g_hash_table_remove (manager->priv->server_list, server_object);
ods_manager_listened_names_remove (manager, owner, server_object);
g_free (server_object);
g_free (owner);
}
static void
session_closed_cb (OdsSession *session, OdsManager *manager)
{
gchar *session_object;
g_message ("session closed");
g_object_get (session, "dbus-path", &session_object, NULL);
ods_manager_session_list_remove (manager, session);
g_signal_emit (manager, signals [SESSION_CLOSED], 0, session_object);
g_free (session_object);
g_object_unref (session);
}
static void
session_connect_result_cb (OdsSession *session, const gchar *error_name,
const gchar *error_message, OdsManager *manager)
{
gchar *session_object;
g_message ("session_connect_result_cb");
g_object_get (session, "dbus-path", &session_object, NULL);
if (!error_name)
g_signal_emit (manager, signals [SESSION_CONNECTED], 0, session_object);
else {
g_signal_emit (manager, signals [SESSION_CONNECT_ERROR], 0, session_object,
error_name, error_message);
session_closed_cb (session, manager);
}
g_signal_handlers_disconnect_by_func (session,
G_CALLBACK (session_connect_result_cb), manager);
g_free (session_object);
}
static void
server_disposed_cb (OdsServer *server, OdsManager *manager)
{
g_message ("server closed");
/* Free everything */
ods_manager_server_list_remove (manager, server);
g_object_unref (server);
}
static void
server_closed_cb (OdsServer *server, OdsManager *manager)
{
g_message ("disposing server");
g_signal_connect (server, "disposed", G_CALLBACK (server_disposed_cb), manager);
ods_server_dispose (server);
}
static void
server_started_cb (OdsServer *server, OdsManager *manager)
{
OdsManagerServerInfo *server_info;
gchar *server_object;
gchar *path;
guint service;
ImagingSdpData *imagingdata = NULL;
struct statvfs sfs;
guint32 record_handle;
/* Add service record to SDP database */
g_object_get (server, "dbus-path", &server_object, NULL);
g_object_get (server, "path", &path, NULL);
g_object_get (server, "service", &service, NULL);
server_info = g_hash_table_lookup (manager->priv->server_list, server_object);
if (!server_info->bluetooth_source_address) {
/* nothing to do for tty server */
goto out;
}
if (service == ODS_SERVICE_BIP) {
/* ods currently supports ImagePush and RemoteDisplay
* as Imaging Responder */
imagingdata = g_new0 (ImagingSdpData, 1);
imagingdata->supp_capabilities |= BIP_SUPP_CAP_GENERIC_IMAGING;
imagingdata->supp_capabilities |= BIP_SUPP_CAP_DISPLAYING;
imagingdata->supp_features |= BIP_SUPP_FEAT_IMAGE_PUSH;
imagingdata->supp_features |= BIP_SUPP_FEAT_REMOTE_DISPLAY;
imagingdata->supp_functions |= BIP_SUPP_FUNC_GET_CAPABILITIES;
imagingdata->supp_functions |= BIP_SUPP_FUNC_PUT_IMAGE;
imagingdata->supp_functions |= BIP_SUPP_FUNC_PUT_LINKED_ATTACHMENT;
imagingdata->supp_functions |= BIP_SUPP_FUNC_PUT_LINKED_THUMBNAIL;
imagingdata->supp_functions |= BIP_SUPP_FUNC_REMOTE_DISPLAY;
if (statvfs (path, &sfs) == -1)
imagingdata->data_capacity = 0;
else
imagingdata->data_capacity = (guint64)sfs.f_frsize * sfs.f_bfree;
}
record_handle = ods_bluez_add_service_record (
server_info->bluetooth_source_address,
service, imagingdata);
if (record_handle == 0) {
/* could not add SDP record */
g_warning ("Could not add SDP record for server (%s), closing server",
server_object);
/* stop server */
g_signal_connect (server, "disposed", G_CALLBACK (server_disposed_cb), manager);
g_object_run_dispose (G_OBJECT (server));
} else {
server_info->sdp_record_handle = record_handle;
}
out:
g_free (server_object);
g_free (path);
if (imagingdata)
g_free (imagingdata);
}
static void
server_stopped_cb (OdsServer *server, OdsManager *manager)
{
OdsManagerServerInfo *server_info;
gchar *server_object;
g_message ("server stopped");
g_object_get (server, "dbus-path", &server_object, NULL);
/* Remove SDP record (Bluetooth specific) */
server_info = g_hash_table_lookup (manager->priv->server_list, server_object);
if (!server_info)
goto out;
if (server_info->sdp_record_handle &&
server_info->bluetooth_source_address) {
ods_bluez_remove_service_record (server_info->bluetooth_source_address,
server_info->sdp_record_handle);
}
out:
g_free (server_object);
}
static void
session_cancelled_cb (OdsSession *session, OdsManager *manager)
{
GError *error = NULL;
g_message ("session cancelled");
g_signal_connect (session, "disconnected",
G_CALLBACK (session_closed_cb), manager);
if (ods_session_disconnect_internal (session, &error) == -1) {
/* shouldn't ever happen */
g_clear_error (&error);
}
}
static void
ods_manager_finalize_object (gpointer *object, OdsManager *manager)
{
OdsManagerSessionInfo *session_info;
OdsManagerServerInfo *server_info;
/* Determine whether we have to close a session or a server */
if ((session_info = g_hash_table_lookup (manager->priv->session_list,
object))) {
g_warning ("Finalizing session");
ods_manager_session_finalize (NULL, session_info, manager);
} else if ((server_info = g_hash_table_lookup (manager->priv->server_list,
object))) {
g_warning ("Finalizing server");
ods_manager_server_finalize (NULL, server_info, manager);
}
}
static void
dbus_name_owner_changed_cb (DBusGProxy *dbus_proxy, const gchar *name,
const gchar *old_owner, const gchar *new_owner,
OdsManager *manager)
{
GHashTable *object_list;
GList *object_list_dup;
if (*new_owner != '\0')
return;
/* Lookup this name */
object_list = g_hash_table_lookup (manager->priv->listened_dbus_names, name);
if (object_list == NULL ||
(g_hash_table_lookup (manager->priv->removed_dbus_names, name) != NULL))
return;
g_warning ("DBUS NAME REMOVED: %s", name);
/* insert into removed_dbus_names cause NameOwnerChanged signal
* might be received twice. Use manager as bogus value */
g_hash_table_insert (manager->priv->removed_dbus_names, g_strdup (name), manager);
/* Now we finalize all objects (sessions and servers) */
object_list_dup = ods_hash_table_get_keys (object_list);
g_list_foreach (object_list_dup, (GFunc) ods_manager_finalize_object, manager);
g_list_free (object_list_dup);
}
static void
client_socket_connected_cb (gint fd, gint rfcomm_channel,
const ImagingSdpData *imagingdata, GError *error,
OdsManagerCreateSessionData *data)
{
gchar *session_object = NULL;
gchar *owner = NULL;
OdsManagerSessionInfo *session_info;
g_object_get (data->session, "dbus-path", &session_object, NULL);
g_object_get (data->session, "owner", &owner, NULL);
/* We need to reset cancel_data for this session so that it is
* properly finalized later on */
session_info = g_hash_table_lookup (data->manager->priv->session_list,
session_object);
g_assert (session_info);
if (session_info->bluetooth_cancel_data)
session_info->bluetooth_cancel_data = NULL;
session_info->bluetooth_channel = rfcomm_channel;
if (fd == -1) {
gchar *error_name;
/* Could not connect, emit SessionConnectError */
error_name = ods_error_get_dbus_name (error);
g_signal_emit (data->manager, signals [SESSION_CONNECT_ERROR], 0,
session_object, error_name, error->message);
g_free (error_name);
/* Finalize session object*/
session_closed_cb (data->session, data->manager);
goto out;
}
if (imagingdata) {
g_message ("Imaging SDP data:");
g_message (">> capabilities: %" G_GUINT16_FORMAT, imagingdata->supp_capabilities);
g_message (">> features: %" G_GUINT16_FORMAT, imagingdata->supp_features);
g_message (">> functions: %" G_GUINT32_FORMAT, imagingdata->supp_functions);
g_message (">> capacity: %" G_GUINT64_FORMAT, imagingdata->data_capacity);
g_object_set (data->session, "imaging-sdp-data", imagingdata, NULL);
}
g_message ("Session created by: %s", owner);
/* Connect to the session objects signals. */
g_signal_connect (data->session, "closed",
G_CALLBACK (session_closed_cb), data->manager);
g_signal_connect (data->session, "connect-result-internal",
G_CALLBACK (session_connect_result_cb), data->manager);
/* Set the connected socket as session fd.
* The session will automatically do OBEX Connect */
g_object_set (data->session, "fd", fd, NULL);
out:
g_free (owner);
g_free (session_object);
g_free (data);
}
static struct {
const char *name;
uint16_t class;
gint service;
} ods_services[] = {
{ "pbap", PBAP_SVCLASS_ID, ODS_SERVICE_PBAP},
{ "ftp", OBEX_FILETRANS_SVCLASS_ID, ODS_SERVICE_FTP },
{ "bip", IMAGING_RESPONDER_SVCLASS_ID, ODS_SERVICE_BIP },
{ "opp", OBEX_OBJPUSH_SVCLASS_ID, ODS_SERVICE_OPP },
{ }
};
static gboolean
pattern2service (const char *pattern, uint16_t *uuid, gint *service)
{
int i;
for (i = 0; ods_services[i].name; i++) {
if (strcasecmp (ods_services[i].name, pattern) == 0) {
*uuid = ods_services[i].class;
*service = ods_services[i].service;
return TRUE;
}
}
return FALSE;
}
static gboolean
string2service (const char *string, uuid_t *uuid, gint *service)
{
uint32_t data0, data4;
uint16_t data1, data2, data3, data5;
if (uuid && strlen(string) == 36 &&
string[8] == '-' &&
string[13] == '-' &&
string[18] == '-' &&
string[23] == '-' &&
sscanf(string, "%08x-%04hx-%04hx-%04hx-%08x%04hx",
&data0, &data1, &data2, &data3, &data4, &data5) == 6) {
uint8_t val[16];
data0 = g_htonl(data0);
data1 = g_htons(data1);
data2 = g_htons(data2);
data3 = g_htons(data3);
data4 = g_htonl(data4);
data5 = g_htons(data5);
memcpy(&val[0], &data0, 4);
memcpy(&val[4], &data1, 2);
memcpy(&val[6], &data2, 2);
memcpy(&val[8], &data3, 2);
memcpy(&val[10], &data4, 4);
memcpy(&val[14], &data5, 2);
sdp_uuid128_create (uuid, val);
/* we got UUID128, let's use generic GOEP service */
*service = ODS_SERVICE_GOEP;
return TRUE;
} else {
uint16_t class;
/* got pattern specifying exactly which service to use */
if (pattern2service (string, &class, service)) {
if (uuid)
sdp_uuid16_create (uuid, class);
return TRUE;
}
}
return FALSE;
}
static gint
tty_open (const gchar *tty_dev, GError **error)
{
int fd, arg;
glong flags;
struct termios options;
fd = open (tty_dev, O_RDWR | O_NOCTTY);
if (fd < 0)
goto failed;
flags = fcntl (fd, F_GETFL);
fcntl (fd, F_SETFL, flags & ~O_NONBLOCK);
tcgetattr (fd, &options);
cfmakeraw (&options);
options.c_oflag &= ~ONLCR;
tcsetattr (fd, TCSANOW, &options);
arg = fcntl (fd, F_GETFL);
if (arg < 0)
goto failed;
arg |= O_NONBLOCK;
if (fcntl (fd, F_SETFL, arg) < 0)
goto failed;
g_message ("TTY device %s opened", tty_dev);
return fd;
failed:
if (fd >= 0)
close (fd);
ods_error_err2gerror (errno, error);
if (g_error_matches (*error, ODS_ERROR, ODS_ERROR_FAILED)) {
/* replace "unknown errno" error with more readable one */
g_debug ("Unknown err code: (%d)", errno);
g_clear_error (error);
g_set_error (error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not open tty device");
}
return -errno;
}
static gboolean
create_bluetooth_session_full (OdsManager *manager,
const gchar *target_address,
const gchar *source_address,
const gchar *pattern,
const gchar *bip_feature,
DBusGMethodInvocation *context)
{
GError *error = NULL;
gboolean ret = TRUE;
gboolean valid;
bdaddr_t src;
bdaddr_t dst;
uuid_t uuid;
gint service;
gchar **parsed = NULL;
OdsSession *session;
gchar *sender;
gchar *session_object;
gchar *target_uuid = NULL;
guint imaging_feature = 0;
OdsBluezCancellable *cancel_data;
g_return_val_if_fail (manager != NULL, FALSE);
g_return_val_if_fail (ODS_IS_MANAGER (manager), FALSE);
/* check target address validity */
str2ba (target_address, &dst);
/* can be only real address */
valid = bachk (target_address) == 0 &&
bacmp (&dst, BDADDR_ANY) &&
bacmp (&dst, BDADDR_ALL);
if (!valid) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid target Bluetooth address");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
/* check address validity */
str2ba (source_address, &src);
/* can be real address or BDADDR_ANY */
valid = bachk (source_address) == 0 &&
bacmp (&src, BDADDR_ALL);
if (!valid) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid source Bluetooth address");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
/* format of pattern at this point should be [:] */
parsed = g_strsplit (pattern, ":", 2);
/* convert pattern to service and bluetooth UUID */
if (!string2service (parsed[0], &uuid, &service)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid pattern");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
/* determine target UUID according to service */
switch (service) {
case ODS_SERVICE_FTP:
target_uuid = OBEX_FTP_UUID;
break;
case ODS_SERVICE_PBAP:
target_uuid = OBEX_PBAP_UUID;
break;
case ODS_SERVICE_BIP:
if (!g_ascii_strcasecmp (bip_feature, ODS_MANAGER_BIP_IMAGEPUSH_STR)) {
target_uuid = OBEX_BIP_IPUSH_UUID;
imaging_feature = BIP_SUPP_FEAT_IMAGE_PUSH;
} else if (!g_ascii_strcasecmp (bip_feature, ODS_MANAGER_BIP_REMOTEDISPLAY_STR)) {
target_uuid = OBEX_BIP_RD_UUID;
imaging_feature = BIP_SUPP_FEAT_REMOTE_DISPLAY;
} else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Unknown imaging feature");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
break;
}
/* Create a session object */
sender = dbus_g_method_get_sender (context);
session = ods_session_new (-1, -1, service, sender, target_uuid);
if (imaging_feature != 0)
g_object_set (session, "imaging-feature", imaging_feature, NULL);
g_object_get (session, "dbus-path", &session_object, NULL);
/* connect Bluetooth transport (ods-bluez.c) */
OdsManagerCreateSessionData *cb_data;/* data to pass to callback */
cb_data = g_new0 (OdsManagerCreateSessionData, 1);
cb_data->manager = manager;
cb_data->session = session;
/* start connecting socket for session */
if (parsed[0])
g_message ("Parsed[0]: %s", parsed[0]);
if (parsed[1])
g_message ("Parsed[1]: %s", parsed[1]);
cancel_data = ods_bluez_get_client_socket (&dst, &src, &uuid,
imaging_feature,
(g_strv_length (parsed)>1 ? atoi (parsed[1]) : 0),
(OdsBluezFunc) client_socket_connected_cb,
cb_data);
ods_manager_session_list_add (cb_data->manager, cb_data->session,
cancel_data,
target_address, source_address, -1, NULL,
sender, session_object);
if (!cancel_data) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
"Service search failed (%s)", strerror (errno));
client_socket_connected_cb (-1, -1, NULL, error, cb_data);
/* SessionConnectError will be emitted immediately after session obj is returned */
}
/* Return session object now, SessionConnected will be emitted when
* session is fully connected */
dbus_g_method_return (context, session_object);
g_free (sender);
g_free (session_object);
out:
if (error)
g_clear_error (&error);
if (parsed)
g_strfreev (parsed);
return ret;
}
/**
* ods_manager_create_bluetooth_session:
* @manager: This class instance
* @target_address: Bluetooth address of remote device to connect to
* @source_address: Bluetooth address of local device (adapter)
* @pattern: OBEX UUID (commonly "opp", "ftp", etc.)
*
* Creates and auto-connects Bluetooth session.
*
* Return value:
**/
gboolean
ods_manager_create_bluetooth_session (OdsManager *manager,
const gchar *target_address,
const gchar *source_address,
const gchar *pattern,
DBusGMethodInvocation *context)
{
return create_bluetooth_session_full (manager, target_address, source_address,
pattern, NULL, context);
}
/**
* ods_manager_create_usb_session:
* @manager: This class instance
* @interface_number: USB OBEX interface number to connect to
* @pattern: service used (commonly "ftp")
*
* Creates and auto-connects USB session.
*
* Return value:
**/
gboolean
ods_manager_create_usb_session (OdsManager *manager,
const gint interface_number,
const gchar *pattern,
DBusGMethodInvocation *context)
{
GError *error = NULL;
gboolean ret = TRUE;
OdsSession *session;
gint service;
gchar *target_uuid = NULL;
gchar *sender;
gchar *session_object;
g_return_val_if_fail (manager != NULL, FALSE);
g_return_val_if_fail (ODS_IS_MANAGER (manager), FALSE);
if (interface_number < 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid USB interface number");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
/* convert pattern to service and bluetooth UUID */
if (!string2service (pattern, NULL, &service)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid pattern");
dbus_g_method_return_error (context, error);
ret = FALSE;
goto out;
}
/* FIXME detect unsuported services and error out */
if (service == ODS_SERVICE_FTP)
target_uuid = OBEX_FTP_UUID;
/* Create a session object */
sender = dbus_g_method_get_sender (context);
session = ods_session_new (-1, -1, service, sender, target_uuid);
g_object_get (session, "dbus-path", &session_object, NULL);
ods_manager_session_list_add (manager, session,
NULL, NULL, NULL, interface_number, NULL,
sender, session_object);
g_message ("Session created by: %s", sender);
/* Connect to the session objects signals. */
g_signal_connect (session, "closed",
G_CALLBACK (session_closed_cb), manager);
g_signal_connect (session, "connect-result-internal",
G_CALLBACK (session_connect_result_cb), manager);
/* Set USB interface number.
* The session will automatically do OBEX Connect */
g_object_set (session, "usbintfnum", interface_number, NULL);
/* Return session object now, SessionConnected will be emitted when
* session is fully connected */
dbus_g_method_return (context, session_object);
g_free (sender);
g_free (session_object);
out:
if (error)
g_clear_error (&error);
return ret;
}
static gboolean
connect_tty_session (gpointer data)
{
OdsManagerCreateSessionData *cb_data = (OdsManagerCreateSessionData*) data;
gint fd;
gchar *session_object = NULL;
GError *error = NULL;
gchar *error_name = NULL;
/* open tty device */
fd = tty_open (cb_data->tty_dev, &error);
if (fd < 0) {
g_object_get (cb_data->session, "dbus-path", &session_object, NULL);
/* Could not connect, emit SessionConnectError */
error_name = ods_error_get_dbus_name (error);
g_signal_emit (cb_data->manager, signals [SESSION_CONNECT_ERROR], 0,
session_object, error_name, error->message);
/* Finalize session object*/
session_closed_cb (cb_data->session, cb_data->manager);
g_clear_error (&error);
g_free (session_object);
g_free (error_name);
} else {
/* Connect to the session objects signals. */
g_signal_connect (cb_data->session, "closed",
G_CALLBACK (session_closed_cb), cb_data->manager);
g_signal_connect (cb_data->session, "connect-result-internal",
G_CALLBACK (session_connect_result_cb), cb_data->manager);
g_object_set (cb_data->session, "fd", fd, NULL);
}
g_free (cb_data->tty_dev);
g_free (cb_data);
return FALSE;
}
gboolean
ods_manager_create_tty_session (OdsManager *manager,
const gchar *tty_dev,
const gchar *pattern,
DBusGMethodInvocation *context)
{
GError *error = NULL;
OdsSession *session;
gint service;
gchar *target_uuid = NULL;
gchar *sender = NULL;
gchar *session_object = NULL;
OdsManagerCreateSessionData *cb_data;
g_return_val_if_fail (manager != NULL, FALSE);
g_return_val_if_fail (ODS_IS_MANAGER (manager), FALSE);
/* convert pattern to service and bluetooth UUID */
if (!string2service (pattern, NULL, &service)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid pattern");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* FIXME detect unsuported services and error out */
if (service == ODS_SERVICE_FTP)
target_uuid = OBEX_FTP_UUID;
/* Create a session object */
sender = dbus_g_method_get_sender (context);
session = ods_session_new (-1, -1, service, sender, target_uuid);
g_object_get (session, "dbus-path", &session_object, NULL);
ods_manager_session_list_add (manager, session,
NULL, NULL, NULL, -1, tty_dev,
sender, session_object);
g_message ("Session created by: %s", sender);
/* connect will happen later in connect_tty_session */
cb_data = g_new0 (OdsManagerCreateSessionData, 1);
cb_data->manager = manager;
cb_data->session = session;
cb_data->tty_dev = g_strdup (tty_dev);
g_idle_add (connect_tty_session, cb_data);
/* Return session object now, SessionConnected will be emitted when
* session is fully connected */
dbus_g_method_return (context, session_object);
g_free (sender);
g_free (session_object);
return TRUE;
}
/**
* ods_manager_get_usb_interfaces_num:
* @manager: This class instance
*
* Returns number of currently available USB OBEX interfaces
*
* Return value:
**/
guint
ods_manager_get_usb_interfaces_num (OdsManager *manager)
{
#ifdef USE_USB
GList *list;
guint num_interfaces;
list = ods_usbobex_find_interfaces ();
num_interfaces = g_list_length (list);
ods_usbobex_free_interfaces (list);
return num_interfaces;
#else
return 0;
#endif /* USE_USB */
}
/**
* ods_manager_get_usb_interfaces_info:
* @manager: This class instance
* @interface_number: the number of interface to return information about
*
* Returns information about a specific USB USB OBEX interface
*
* Return value:
**/
GHashTable *
ods_manager_get_usb_interface_info (OdsManager *manager, const gint interface_number)
{
#ifdef USE_USB
ods_usb_info *item;
GList *list;
#endif
GHashTable *info;
info = g_hash_table_new_full ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal, NULL, (GDestroyNotify) g_free);
#ifdef USE_USB
list = ods_usbobex_find_interfaces();
item = g_list_nth_data (list, interface_number);
if (item == NULL) {
g_warning("No such USB interface, requested interface %d info", interface_number);
return info;
}
g_message ("item->path %s", item->path);
g_hash_table_insert (info, "Manufacturer",
g_strdup (item->manufacturer));
g_hash_table_insert (info, "Product",
g_strdup (item->product));
g_hash_table_insert (info, "Serial",
g_strdup (item->serial));
g_hash_table_insert (info, "Configuration",
g_strdup (item->configuration));
g_hash_table_insert (info, "ControlInterface",
g_strdup (item->control_interface));
g_hash_table_insert (info, "DataInterfaceIdle",
g_strdup (item->data_interface_idle));
g_hash_table_insert (info, "DataInterfaceActive",
g_strdup (item->data_interface_active));
g_hash_table_insert (info, "Path",
g_strdup (item->path));
ods_usbobex_free_interfaces (list);
#endif /* USE_USB */
return info;
}
gboolean
ods_manager_create_bluetooth_imaging_session (OdsManager *manager,
const gchar *target_address,
const gchar *source_address,
const gchar *bip_feature,
DBusGMethodInvocation *context)
{
gchar **parsed;
gchar *pattern;
gboolean ret;
parsed = g_strsplit (bip_feature, ":", 2);
if (g_strv_length (parsed)>1)
pattern = g_strdup_printf (ODS_MANAGER_BIP_STR ":%s", parsed[1]);
else
pattern = g_strdup (ODS_MANAGER_BIP_STR);
ret = create_bluetooth_session_full (manager, target_address, source_address,
pattern, parsed[0], context);
g_strfreev (parsed);
g_free (pattern);
return ret;
}
static gboolean
cancel_session_connect (OdsManager *manager,
OdsManagerSessionInfo *session_info)
{
if (session_info->bluetooth_cancel_data) {
ods_bluez_cancel_get_client_socket (session_info->bluetooth_cancel_data);
return TRUE;
}
/* for future reference: Check for other transports cancellables */
return FALSE;
}
gboolean
ods_manager_cancel_session_connect (OdsManager *manager,
const gchar *session_object)
{
OdsManagerSessionInfo *session_info;
session_info = g_hash_table_lookup (manager->priv->session_list, session_object);
if (!session_info)
return FALSE;
return cancel_session_connect (manager, session_info);
}
gboolean
ods_manager_create_bluetooth_server (OdsManager *manager,
const gchar *source_address,
const gchar *pattern,
gboolean require_pairing,
DBusGMethodInvocation *context)
{
GError *error = NULL;
gboolean valid;
bdaddr_t bd_address;
gint service;
guint8 channel;
gint fd;
gint sockopt;
OdsServer *server;
gchar *sender;
gchar *server_object;
g_return_val_if_fail (manager != NULL, FALSE);
g_return_val_if_fail (ODS_IS_MANAGER (manager), FALSE);
/* check address validity */
str2ba (source_address, &bd_address);
/* can be real address or BDADDR_ANY */
valid = bachk (source_address) == 0 &&
bacmp (&bd_address, BDADDR_ALL);
if (!valid) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid Bluetooth address");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* check pattern validity (has to be supported/known service */
if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_FTP_STR)) {
service = ODS_SERVICE_FTP;
channel = ODS_FTP_RFCOMM_CHANNEL;
} else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_OPP_STR)) {
service = ODS_SERVICE_OPP;
channel = ODS_OPP_RFCOMM_CHANNEL;
} else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_PBAP_STR)) {
service = ODS_SERVICE_PBAP;
channel = ODS_PBAP_RFCOMM_CHANNEL;
} else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_BIP_STR)) {
service = ODS_SERVICE_BIP;
channel = ODS_BIP_RFCOMM_CHANNEL;
} else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid pattern");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* create server socket */
fd = ods_bluez_get_server_socket (source_address, channel);
if (fd == -1) {
/* could not create server socket */
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not create server socket");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
g_message ("server socket created");
/* require_pairing */
if (require_pairing) {
sockopt = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT;
if (setsockopt (fd, SOL_RFCOMM, RFCOMM_LM, &sockopt, sizeof (sockopt)) < 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Setting RFCOMM link mode failed");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
}
/* create server object and return it's object path */
sender = dbus_g_method_get_sender (context);
g_message ("Server created by: %s", sender);
server = ods_server_new (fd, service, sender);
/* add server to server list */
g_object_get (server, "dbus-path", &server_object, NULL);
ods_manager_server_list_add (manager, server, source_address, require_pairing,
0, NULL, sender, server_object);
/* deal with signals */
g_signal_connect (server, "started", G_CALLBACK (server_started_cb), manager);
g_signal_connect (server, "stopped", G_CALLBACK (server_stopped_cb), manager);
g_signal_connect (server, "closed", G_CALLBACK (server_closed_cb), manager);
/* return server object path */
dbus_g_method_return (context, server_object);
g_free (sender);
g_free (server_object);
return TRUE;
}
gboolean
ods_manager_create_tty_server (OdsManager *manager,
const gchar *tty_dev,
const gchar *pattern,
DBusGMethodInvocation *context)
{
GError *error = NULL;
gint service;
gint fd;
OdsServer *server;
gchar *sender;
gchar *server_object;
g_return_val_if_fail (manager != NULL, FALSE);
g_return_val_if_fail (ODS_IS_MANAGER (manager), FALSE);
/* check pattern validity (has to be supported/known service */
if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_FTP_STR))
service = ODS_SERVICE_FTP;
else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_OPP_STR))
service = ODS_SERVICE_OPP;
else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_PBAP_STR))
service = ODS_SERVICE_PBAP;
else if (!g_ascii_strcasecmp (pattern, ODS_MANAGER_BIP_STR))
service = ODS_SERVICE_BIP;
else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid pattern");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* open tty device */
fd = tty_open (tty_dev, &error);
if (fd < 0) {
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* create server object and return it's object path */
sender = dbus_g_method_get_sender (context);
g_message ("Server created by: %s", sender);
server = ods_server_new (fd, service, sender);
g_object_set (server, "tty-dev", tty_dev, NULL);
/* add server to server list */
g_object_get (server, "dbus-path", &server_object, NULL);
ods_manager_server_list_add (manager, server, NULL, FALSE, 0, tty_dev,
sender, server_object);
/* deal with signals */
g_signal_connect (server, "started", G_CALLBACK (server_started_cb), manager);
g_signal_connect (server, "stopped", G_CALLBACK (server_stopped_cb), manager);
g_signal_connect (server, "closed", G_CALLBACK (server_closed_cb), manager);
/* return server object path */
dbus_g_method_return (context, server_object);
g_free (sender);
g_free (server_object);
return TRUE;
}
GHashTable *
ods_manager_get_session_info (OdsManager *manager, gchar *session_object)
{
GHashTable *info;
OdsManagerSessionInfo *session_info;
info = g_hash_table_new ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
session_info = g_hash_table_lookup (manager->priv->session_list, session_object);
if (session_info) {
if (session_info->bluetooth_target_address) {
g_hash_table_insert (info, "BluetoothTargetAddress",
g_strdup (session_info->bluetooth_target_address));
g_hash_table_insert (info, "BluetoothSourceAddress",
g_strdup (session_info->bluetooth_source_address));
g_hash_table_insert (info, "BluetoothChannel",
g_strdup_printf ("%d", session_info->bluetooth_channel));
}
if (session_info->usb_interface_number > 0) {
g_hash_table_insert (info, "UsbInterfaceNumber",
g_strdup_printf ("%d", session_info->usb_interface_number));
}
if (session_info->tty_dev) {
g_hash_table_insert (info, "TTYDevice",
g_strdup (session_info->tty_dev));
}
}
return info;
}
GHashTable *
ods_manager_get_server_info (OdsManager *manager, gchar *server_object)
{
GHashTable *info;
OdsManagerServerInfo *server_info;
info = g_hash_table_new ((GHashFunc)g_str_hash, (GEqualFunc)g_str_equal);
server_info = g_hash_table_lookup (manager->priv->server_list, server_object);
if (server_info) {
if (server_info->bluetooth_source_address) {
g_hash_table_insert (info, "BluetoothSourceAddress",
g_strdup (server_info->bluetooth_source_address));
g_hash_table_insert (info, "RequirePairing",
g_strdup (server_info->require_pairing ? "True": "False"));
}
if (server_info->tty_dev) {
g_hash_table_insert (info, "TTYDevice",
g_strdup (server_info->tty_dev));
}
}
return info;
}
gchar**
ods_manager_get_session_list (OdsManager *manager)
{
return ods_hash_table_keys2strv (manager->priv->session_list);
}
gchar**
ods_manager_get_server_list (OdsManager *manager)
{
return ods_hash_table_keys2strv (manager->priv->server_list);
}
gchar*
ods_manager_get_version (OdsManager *manager)
{
return g_strdup_printf ("%s:%d", PACKAGE_VERSION, ODS_API_VERSION);
}
/**
* ods_manager_class_init:
* @klass: The OdsManagerClass
**/
static void
ods_manager_class_init (OdsManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = ods_manager_finalize;
signals [SESSION_CONNECTED] =
g_signal_new ("session-connected",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsManagerClass, session_connected),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
signals [SESSION_CLOSED] =
g_signal_new ("session-closed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsManagerClass, session_closed),
NULL,
NULL,
g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, DBUS_TYPE_G_OBJECT_PATH);
signals [SESSION_CONNECT_ERROR] =
g_signal_new ("session-connect-error",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsManagerClass, session_connect_error),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING_STRING,
G_TYPE_NONE, 3, DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING, G_TYPE_STRING);
signals [DISPOSED] =
g_signal_new ("disposed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsManagerClass, disposed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
g_type_class_add_private (klass, sizeof (OdsManagerPrivate));
GError *error = NULL;
/* Init the DBus connection, per-klass */
klass->connection = dbus_g_bus_get (ODS_DBUS_BUS, &error);
if (klass->connection == NULL) {
g_warning("Unable to connect to dbus: %s", error->message);
g_clear_error (&error);
return;
}
/* &dbus_glib_ods_manager_object_info is provided in the
* dbus/ods-manager-dbus-glue.h file */
dbus_g_object_type_install_info (ODS_TYPE_MANAGER, &dbus_glib_ods_manager_object_info);
/* also register global error domain */
dbus_g_error_domain_register (ODS_ERROR, ODS_ERROR_DBUS_INTERFACE, ODS_TYPE_ERROR);
}
/**
* ods_manager_init:
* @manager: This class instance
**/
static void
ods_manager_init (OdsManager *manager)
{
OdsManagerClass *klass = ODS_MANAGER_GET_CLASS (manager);
manager->priv = ODS_MANAGER_GET_PRIVATE (manager);
manager->priv->session_list = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) ods_manager_session_info_free);
manager->priv->server_list = g_hash_table_new_full (g_str_hash, g_str_equal,
g_free, (GDestroyNotify) ods_manager_server_info_free);
manager->priv->initialized = TRUE;/* For future use */
manager->priv->dbus_proxy = dbus_g_proxy_new_for_name (klass->connection,
DBUS_SERVICE_DBUS,
DBUS_PATH_DBUS,
DBUS_INTERFACE_DBUS);
dbus_g_proxy_add_signal (manager->priv->dbus_proxy, "NameOwnerChanged",
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (manager->priv->dbus_proxy, "NameOwnerChanged",
G_CALLBACK (dbus_name_owner_changed_cb),
manager, NULL);
manager->priv->listened_dbus_names = g_hash_table_new_full (g_str_hash,
g_str_equal, g_free, (GDestroyNotify) g_hash_table_unref);
manager->priv->removed_dbus_names = g_hash_table_new_full (g_str_hash,
g_str_equal, g_free, NULL);
dbus_g_connection_register_g_object (klass->connection,
ODS_MANAGER_DBUS_PATH,
G_OBJECT (manager));
}
static gboolean
ods_manager_session_finalize (gpointer key, OdsManagerSessionInfo *session_info,
OdsManager *manager)
{
g_message ("attempting to close session");
/* If session is being connected, cancel */
if (cancel_session_connect (manager, session_info))
return TRUE;
/* Finalize already connected session */
g_signal_connect (session_info->session, "cancelled",
G_CALLBACK (session_cancelled_cb), manager);
ods_session_cancel_internal (session_info->session);
/* Even if there was nothing to cancel, we will get
* CANCELLED signal and disconnection will happen in
* session_cancelled_cb */
return TRUE;
}
static gboolean
ods_manager_server_finalize (gpointer key, OdsManagerServerInfo *server_info,
OdsManager *manager)
{
OdsServer *server = server_info->server;
/* STOPPED signal will not be emitted, call teh callback now */
server_stopped_cb (server, manager);
g_signal_connect (server, "disposed", G_CALLBACK (server_disposed_cb), manager);
ods_server_dispose (server);
return TRUE;
}
void
ods_manager_dispose (OdsManager *manager)
{
g_return_if_fail (manager != NULL);
g_return_if_fail (ODS_IS_MANAGER (manager));
g_return_if_fail (manager->priv != NULL);
if (manager->priv->disposed)
return;
g_message ("Disposing manager");
manager->priv->is_disposing = TRUE;
/* check if there is nothing to dispose */
if (g_hash_table_size (manager->priv->listened_dbus_names) == 0) {
g_message ("Manager disposed at once");
manager->priv->disposed = TRUE;
g_signal_emit (manager, signals [DISPOSED], 0);
} else {
g_hash_table_foreach_remove (manager->priv->session_list,
(GHRFunc) ods_manager_session_finalize, manager);
g_hash_table_foreach_remove (manager->priv->server_list,
(GHRFunc) ods_manager_server_finalize, manager);
}
}
/**
* ods_manager_finalize:
* @object: The object to finalize
*
* Finalise the manager, by unref'ing all the depending modules.
**/
static void
ods_manager_finalize (GObject *object)
{
OdsManager *manager;
g_return_if_fail (object != NULL);
g_return_if_fail (ODS_IS_MANAGER (object));
manager = ODS_MANAGER (object);
g_return_if_fail (manager->priv != NULL);
g_return_if_fail (manager->priv->disposed);
g_message ("Finalizing manager");
ods_bluez_finalize();
g_hash_table_unref (manager->priv->listened_dbus_names);
g_hash_table_unref (manager->priv->session_list);
g_hash_table_unref (manager->priv->server_list);
g_object_unref (G_OBJECT (manager->priv->dbus_proxy));
G_OBJECT_CLASS (ods_manager_parent_class)->finalize (object);
}
/**
* ods_manager_new:
*
* Return value: a new OdsManager object.
**/
OdsManager *
ods_manager_new (void)
{
OdsManager *manager;
manager = g_object_new (ODS_TYPE_MANAGER, NULL);
return ODS_MANAGER (manager);
}
/**
* ods_manager_is_initialized:
* @manager: OdsManager instance
*
* Checks if object was initialized succesfully. Might not be initialized
* if OdsBluez was not initialized successfully
*
* Return value: TRUE for success, FALSE otherwise.
**/
gboolean
ods_manager_is_initialized (OdsManager *manager)
{
return manager->priv->initialized;
}
obex-data-server-0.4.6/src/ods-manager.h 0000644 0001750 0001750 00000011034 11524724173 014754 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_MANAGER_H
#define __ODS_MANAGER_H
#include
#include
#include "ods-common.h"
G_BEGIN_DECLS
#define ODS_MANAGER_DBUS_PATH "/org/openobex"
#define ODS_MANAGER_DBUS_INTERFACE "org.openobex.Manager"
#define ODS_MANAGER_OPP_STR "opp"
#define ODS_MANAGER_FTP_STR "ftp"
#define ODS_MANAGER_PBAP_STR "pbap"
#define ODS_MANAGER_BIP_STR "bip"
#define ODS_MANAGER_BIP_IMAGEPUSH_STR "imagepush"
#define ODS_MANAGER_BIP_REMOTEDISPLAY_STR "remotedisplay"
#define ODS_TYPE_MANAGER (ods_manager_get_type ())
#define ODS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), ODS_TYPE_MANAGER, OdsManager))
#define ODS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), ODS_TYPE_MANAGER, OdsManagerClass))
#define ODS_IS_MANAGER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), ODS_TYPE_MANAGER))
#define ODS_IS_MANAGER_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), ODS_TYPE_MANAGER))
#define ODS_MANAGER_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), ODS_TYPE_MANAGER, OdsManagerClass))
typedef struct OdsManagerPrivate OdsManagerPrivate;
typedef struct
{
GObject parent;
OdsManagerPrivate *priv;
} OdsManager;
typedef struct
{
GObjectClass parent_class;
void (* session_connected) (OdsManager *manager,
const gchar *session_object);
void (* session_closed) (OdsManager *manager,
const gchar *session_object);
void (* session_connect_error)(OdsManager *manager,
const gchar *session_object,
const gchar *error_name,
const gchar *error_message);
void (* disposed) (OdsManager *manager);
DBusGConnection *connection;
} OdsManagerClass;
GType ods_manager_get_type (void);
OdsManager *ods_manager_new (void);
gboolean ods_manager_is_initialized (OdsManager *manager);
gboolean ods_manager_create_bluetooth_session (OdsManager *manager,
const gchar *target_address,
const gchar *source_address,
const gchar *pattern,
DBusGMethodInvocation *context);
gboolean ods_manager_create_bluetooth_imaging_session (OdsManager *manager,
const gchar *target_address,
const gchar *source_address,
const gchar *bip_feature,
DBusGMethodInvocation *context);
gboolean ods_manager_create_usb_session (OdsManager *manager,
const gint interface_number,
const gchar *pattern,
DBusGMethodInvocation *context);
gboolean ods_manager_create_tty_session (OdsManager *manager,
const gchar *tty_dev,
const gchar *pattern,
DBusGMethodInvocation *context);
guint ods_manager_get_usb_interfaces_num (OdsManager *manager);
GHashTable *ods_manager_get_usb_interface_info (OdsManager *manager,
const gint interface_number);
gboolean ods_manager_cancel_session_connect (OdsManager *manager,
const gchar *session_object);
gboolean ods_manager_create_bluetooth_server (OdsManager *manager,
const gchar *source_address,
const gchar *pattern,
gboolean require_pairing,
DBusGMethodInvocation *context);
gboolean ods_manager_create_tty_server (OdsManager *manager,
const gchar *tty_dev,
const gchar *pattern,
DBusGMethodInvocation *context);
void ods_manager_dispose (OdsManager *manager);
GHashTable *ods_manager_get_session_info (OdsManager *manager, gchar *session_object);
GHashTable *ods_manager_get_server_info (OdsManager *manager, gchar *server_object);
gchar **ods_manager_get_session_list (OdsManager *manager);
gchar **ods_manager_get_server_list (OdsManager *manager);
gchar *ods_manager_get_version (OdsManager *manager);
G_END_DECLS
#endif /* __ODS_MANAGER_H */
obex-data-server-0.4.6/src/ods-imaging-helpers.c 0000644 0001750 0001750 00000057704 11524724173 016426 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#ifdef USE_IMAGEMAGICK
#include
#endif
#ifdef USE_GDKPIXBUF
#include
#endif
#include "ods-common.h"
#include "ods-imaging-helpers.h"
#define ODS_IMAGING_FILL_COLOR "#FFFFFF"
#define ODS_IMAGING_FILL_COLOR_RGBA 0xFFFFFFFF
#define ODS_IMAGING_TEMPNAME "ods_imageXXXXXX"
/* constants for generating XML */
#define IMG_DESCRIPTOR "" EOL_CHARS
#define IMG_DESCRIPTOR_IMG_SIZE "size=\"%" G_GUINT64_FORMAT "\" "
#define IMG_DESCRIPTOR_IMG_TRANSFORMATION "transformation=\"%s\" "
#define IMG_DESCRIPTOR_IMG "" EOL_CHARS
#define IMG_DESCRIPTOR_END "" EOL_CHARS
#define ATT_DESCRIPTOR "" EOL_CHARS
#define ATT_DESCRIPTOR_ATT_CONTENT_TYPE "content-type=\"%s\" "
#define ATT_DESCRIPTOR_ATT_CHARSET "charset=\"%s\" "
#define ATT_DESCRIPTOR_ATT_CREATED "created=\"%s\" "
#define ATT_DESCRIPTOR_ATT "" EOL_CHARS
#define ATT_DESCRIPTOR_END "" EOL_CHARS
typedef struct OdsImagingCallbackData_ {
OdsImagingFunc func;
OdsImageInfo *data;
gpointer user_data;
} OdsImagingCallbackData;
/* constants for parsing XML */
#define IMG_ELEMENT "image"
#define ATT_ELEMENT "attachment"
typedef struct OdsImgDescriptorParse_ {
/* Used for Image and Attachment descriptors */
gchar **encoding;
gchar **pixel;
guint64 *size;
gchar **transformation;
/* attachment specific */
gchar **name;
gchar **content_type;
gchar **charset;
gchar **created;
} OdsImgDescriptorParse;
/* encoding, pixel and transformation can be empty but must not be NULL */
gchar*
get_image_descriptor (const gchar *encoding, const gchar *pixel, guint64 size,
const gchar *transformation)
{
GString *descriptor;
GString *descriptor_optional;
gchar *descriptor_optional_chr;
g_assert (encoding && pixel && transformation);
descriptor = g_string_new ("");
descriptor_optional = g_string_new ("");
descriptor = g_string_append (descriptor, IMG_DESCRIPTOR);
if (size > 0)
g_string_append_printf (descriptor_optional,
IMG_DESCRIPTOR_IMG_SIZE, size);
if (*transformation != '\0')
g_string_append_printf (descriptor_optional,
IMG_DESCRIPTOR_IMG_TRANSFORMATION, transformation);
descriptor_optional_chr = g_string_free (descriptor_optional, FALSE);
g_string_append_printf (descriptor, IMG_DESCRIPTOR_IMG, encoding,
pixel, descriptor_optional_chr);
descriptor = g_string_append (descriptor, IMG_DESCRIPTOR_END);
g_free (descriptor_optional_chr);
return g_string_free (descriptor, FALSE);
}
/* content_type, charset and created can be empty but must not be NULL */
gchar*
get_attachment_descriptor (const gchar *name, guint64 size, const gchar *content_type,
const gchar *charset, const gchar *created)
{
GString *descriptor;
GString *descriptor_optional;
gchar *descriptor_optional_chr;
g_assert (name && content_type && charset && created);
descriptor = g_string_new ("");
descriptor_optional = g_string_new ("");
descriptor = g_string_append (descriptor, ATT_DESCRIPTOR);
if (*content_type != '\0')
g_string_append_printf (descriptor_optional,
ATT_DESCRIPTOR_ATT_CONTENT_TYPE, content_type);
if (*charset != '\0')
g_string_append_printf (descriptor_optional,
ATT_DESCRIPTOR_ATT_CHARSET, charset);
if (*created != '\0')
g_string_append_printf (descriptor_optional,
ATT_DESCRIPTOR_ATT_CREATED, created);
descriptor_optional_chr = g_string_free (descriptor_optional, FALSE);
g_string_append_printf (descriptor, ATT_DESCRIPTOR_ATT, name,
size, descriptor_optional_chr);
descriptor = g_string_append (descriptor, ATT_DESCRIPTOR_END);
g_free (descriptor_optional_chr);
return g_string_free (descriptor, FALSE);
}
static void
img_parse_element_start (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer data,
GError **error)
{
OdsImgDescriptorParse *out_vars;
gboolean ret;
const gchar *size_str = NULL;
out_vars = (OdsImgDescriptorParse*)data;
if (g_ascii_strncasecmp (element_name, IMG_ELEMENT, strlen (element_name)) &&
g_ascii_strncasecmp (element_name, ATT_ELEMENT, strlen (element_name))) {
/* we are only parsing and elements */
return;
}
ret = g_markup_collect_attributes (element_name, attribute_names,
attribute_values, error,
/* encoding */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"encoding",
out_vars->encoding,
/* pixel */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"pixel",
out_vars->pixel,
/* size */
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL,
"size",
&size_str,
/* maxsize (ignore) */
G_MARKUP_COLLECT_STRING | G_MARKUP_COLLECT_OPTIONAL,
"maxsize",
NULL,
/* transformation */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"transformation",
out_vars->transformation,
/* name */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"name",
out_vars->name,
/* content_type */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"content-type",
out_vars->content_type,
/* charset */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"charset",
out_vars->charset,
/* created */
G_MARKUP_COLLECT_STRDUP | G_MARKUP_COLLECT_OPTIONAL,
"created",
out_vars->created,
G_MARKUP_COLLECT_INVALID);
if (!ret)
g_message ("Parsing descriptor XML data element failed");
if (size_str)
*(out_vars->size) = g_ascii_strtoull (size_str, NULL, 10);
}
static void
parse_descriptor (const gchar *descriptor, OdsImgDescriptorParse *out_vars)
{
GMarkupParser *parser;
GMarkupParseContext *parse_ctx;
gboolean ret;
GError *error = NULL;
g_assert (descriptor);
parser = g_new0 (GMarkupParser, 1);
parser->start_element = img_parse_element_start;
parse_ctx = g_markup_parse_context_new (parser, 0, out_vars, NULL);
ret = g_markup_parse_context_parse (parse_ctx, descriptor,
strlen (descriptor), &error);
/* parsing error is not fatal,
* we can continue without data provided in descriptor */
if (!ret) {
g_message ("Failed to parse descriptor XML data (%s)", error->message);
g_clear_error (&error);
} else {
ret = g_markup_parse_context_end_parse (parse_ctx, &error);
if (!ret) {
g_message ("Failed to parse descriptor XML data (%s)", error->message);
g_clear_error (&error);
}
}
g_markup_parse_context_free (parse_ctx);
g_free (parser);
}
void
parse_image_descriptor (const gchar *descriptor, gchar **encoding,
gchar **pixel, guint64 *size,
gchar **transformation)
{
OdsImgDescriptorParse *out_vars;
g_assert (encoding && pixel && size && transformation);
out_vars = g_new0 (OdsImgDescriptorParse, 1);
out_vars->encoding = encoding;
out_vars->pixel = pixel;
out_vars->size = size;
out_vars->transformation = transformation;
parse_descriptor (descriptor, out_vars);
g_free (out_vars);
}
void
parse_attachment_descriptor (const gchar *descriptor, gchar **name,
guint64 *size, gchar **content_type,
gchar **charset, gchar **created)
{
OdsImgDescriptorParse *out_vars;
g_assert (name && size && content_type && charset && created);
out_vars = g_new0 (OdsImgDescriptorParse, 1);
out_vars->name = name;
out_vars->size = size;
out_vars->content_type = content_type;
out_vars->charset = charset;
out_vars->created = created;
parse_descriptor (descriptor, out_vars);
g_free (out_vars);
}
void
ods_image_info_free (OdsImageInfo *info)
{
if (info->filename)
g_free (info->filename);
if (info->resized_image_filename)
g_free (info->resized_image_filename);
if (info->encoding)
g_free (info->encoding);
g_free (info);
}
gchar*
ods_imaging_get_pixel_string (gulong width, gulong height)
{
return g_strdup_printf ("%lu*%lu", width, height);
}
const gchar*
ods_imaging_get_transformation_string (guint transformation)
{
switch (transformation) {
case ODS_IMAGING_TRANSFORMATION_STRETCH:
return ODS_IMAGING_TRANSFORMATION_STRETCH_STR;
case ODS_IMAGING_TRANSFORMATION_CROP:
return ODS_IMAGING_TRANSFORMATION_CROP_STR;
case ODS_IMAGING_TRANSFORMATION_FILL:
return ODS_IMAGING_TRANSFORMATION_FILL_STR;
default:
return "";
}
}
guint
ods_imaging_get_transformation (const gchar *trans)
{
if (!g_ascii_strcasecmp (trans, ODS_IMAGING_TRANSFORMATION_STRETCH_STR))
return ODS_IMAGING_TRANSFORMATION_STRETCH;
if (!g_ascii_strcasecmp (trans, ODS_IMAGING_TRANSFORMATION_CROP_STR))
return ODS_IMAGING_TRANSFORMATION_CROP;
if (!g_ascii_strcasecmp (trans, ODS_IMAGING_TRANSFORMATION_FILL_STR))
return ODS_IMAGING_TRANSFORMATION_FILL;
return 0;
}
#if defined(USE_IMAGEMAGICK) || defined (USE_GDKPIXBUF)
static gboolean
ods_imaging_thread_callback (OdsImagingCallbackData *cb_data)
{
cb_data->func (cb_data->data, cb_data->user_data);
return FALSE;
}
#endif /* USE_IMAGEMAGICK || USE_GDKPIXBUF */
#ifdef USE_IMAGEMAGICK
static void
ods_imaging_get_image_info (OdsImagingCallbackData *cb_data)
{
MagickBooleanType wand_ret;
MagickWand *magick_wand;
OdsImageInfo *image_info;
struct stat file_stat;
image_info = cb_data->data;
MagickWandGenesis ();
magick_wand = NewMagickWand ();
/* read the image */
wand_ret = MagickReadImage (magick_wand, image_info->filename);
if (wand_ret == MagickFalse)
goto out;
/* get info */
image_info->width = MagickGetImageWidth (magick_wand);
image_info->height = MagickGetImageHeight (magick_wand);
image_info->encoding = MagickGetImageFormat (magick_wand);
if (g_stat (image_info->filename, &file_stat) == 0)
image_info->size = file_stat.st_size;
out:
magick_wand = DestroyMagickWand (magick_wand);
MagickWandTerminus ();
g_idle_add ((GSourceFunc)ods_imaging_thread_callback, cb_data);
}
static void
ods_imaging_resize_image (OdsImagingCallbackData *cb_data)
{
OdsImageInfo *info;
MagickBooleanType ret;
MagickWand *magick_wand;
gchar *current_encoding = NULL;
gulong current_width = 0;
gulong current_height = 0;
gboolean do_resize;
gboolean do_encode;
struct stat file_stat;
g_message("resize_image thread started");
info = cb_data->data;
MagickWandGenesis ();
magick_wand = NewMagickWand ();
/* read the image */
ret = MagickReadImage (magick_wand, info->filename);
if (ret == MagickFalse)
goto out;
/* get image info and determine what we need to do */
current_encoding = MagickGetImageFormat (magick_wand);
current_width = MagickGetImageWidth (magick_wand);
current_height = MagickGetImageHeight (magick_wand);
do_encode = info->encoding && strcmp (info->encoding, current_encoding);
do_resize = (info->width != current_width) ||
(info->height != current_height);
/* resize image if needed */
if (do_resize) {
if (info->transformation == ODS_IMAGING_TRANSFORMATION_CROP) {
/* Transformation CROP */
if (info->width > current_width || info->height > current_height)
info->transformation = ODS_IMAGING_TRANSFORMATION_STRETCH;
else {
ret = MagickCropImage (magick_wand, info->width,
info->height, 0, 0);
if (ret == MagickFalse)
goto out;
}
} else if (info->transformation == ODS_IMAGING_TRANSFORMATION_FILL) {
/* Transformation FILL */
if (info->width < current_width || info->height < current_height)
info->transformation = ODS_IMAGING_TRANSFORMATION_STRETCH;
else {
MagickWand *composite_wand;
PixelWand *pixel_wand;
composite_wand = magick_wand;
magick_wand = NewMagickWand ();
pixel_wand = NewPixelWand ();
PixelSetColor (pixel_wand, ODS_IMAGING_FILL_COLOR);
ret = MagickNewImage (magick_wand, info->width,
info->height, pixel_wand);
if (!info->encoding)
info->encoding = current_encoding;
do_encode = TRUE;
DestroyPixelWand (pixel_wand);
if (ret == MagickFalse) {
DestroyMagickWand (composite_wand);
goto out;
}
ret = MagickCompositeImage (magick_wand, composite_wand,
SrcOverCompositeOp, 0, 0);
DestroyMagickWand (composite_wand);
if (ret == MagickFalse)
goto out;
}
}
if (info->transformation == ODS_IMAGING_TRANSFORMATION_STRETCH) {
ret = MagickThumbnailImage (magick_wand, info->width, info->height);
if (ret == MagickFalse)
goto out;
}
}
/* encode image if needed */
if (do_encode) {
ret = MagickSetImageFormat (magick_wand, info->encoding);
if (ret == MagickFalse)
goto out;
}
/* write resized/encoded image to file */
if (do_resize || do_encode) {
GError *error = NULL;
gint fd;
fd = g_file_open_tmp (ODS_IMAGING_TEMPNAME,
&(info->resized_image_filename), &error);
if (fd == -1) {
g_clear_error (&error);
g_free (info->resized_image_filename);
info->resized_image_filename = NULL;
goto out;
}
close (fd);/* Do this roundtrip because MagickWriteImageFile is buggy */
ret = MagickWriteImage (magick_wand, info->resized_image_filename);
if (ret == MagickFalse) {
g_free (info->resized_image_filename);
info->resized_image_filename = NULL;
goto out;
}
/* get resized image size */
if (g_stat (info->resized_image_filename, &file_stat) == 0)
info->size = file_stat.st_size;
} else {
/* no operations needed to be done, return original filename */
info->resized_image_filename = g_strdup (info->filename);
}
out:
if (current_encoding)
g_free (current_encoding);
magick_wand = DestroyMagickWand (magick_wand);
MagickWandTerminus ();
g_idle_add ((GSourceFunc)ods_imaging_thread_callback, cb_data);
g_message ("resize_image thread finished, adding callback to idle");
}
#endif /* USE_IMAGEMAGICK */
#ifdef USE_GDKPIXBUF
static char *
format_to_encoding (GdkPixbufFormat *format)
{
char *name, *encoding;
name = gdk_pixbuf_format_get_name (format);
encoding = g_ascii_strup (name, -1);
g_free (name);
return encoding;
}
static const char *
encoding_to_pixbuf_format (const char *encoding)
{
/* FIXME should we check the output of gdk_pixbuf_get_formats()
* and gdk_pixbuf_format_is_writable() instead? */
if (strcmp (encoding, "JPEG") == 0)
return "jpeg";
if (strcmp (encoding, "PNG") == 0)
return "png";
if (strcmp (encoding, "BMP") == 0)
return "bmp";
return NULL;
}
static GdkPixbuf *
ods_imaging_pixbuf_new_with_format (const char *filename, char **encoding)
{
GdkPixbuf *pixbuf;
GMappedFile *file;
GdkPixbufLoader *loader;
GdkPixbufFormat *format;
file = g_mapped_file_new (filename, FALSE, NULL);
if (file == NULL)
return NULL;
loader = gdk_pixbuf_loader_new ();
if (gdk_pixbuf_loader_write (loader,
(guchar *) g_mapped_file_get_contents (file),
g_mapped_file_get_length (file),
NULL) == FALSE) {
g_mapped_file_free (file);
g_object_unref (loader);
return NULL;
}
g_mapped_file_free (file);
if (gdk_pixbuf_loader_close (loader, NULL) == FALSE) {
g_object_unref (loader);
return NULL;
}
format = gdk_pixbuf_loader_get_format (loader);
*encoding = format_to_encoding (format);
pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
g_object_unref (loader);
return pixbuf;
}
static void
ods_imaging_get_image_info (OdsImagingCallbackData *cb_data)
{
GdkPixbuf *pixbuf;
OdsImageInfo *image_info;
struct stat file_stat;
image_info = cb_data->data;
g_type_init ();
pixbuf = ods_imaging_pixbuf_new_with_format (image_info->filename,
&image_info->encoding);
if (pixbuf == NULL)
goto out;
/* get info */
image_info->width = gdk_pixbuf_get_width (pixbuf);
image_info->height = gdk_pixbuf_get_height (pixbuf);
if (g_stat (image_info->filename, &file_stat) == 0)
image_info->size = file_stat.st_size;
g_object_unref (pixbuf);
out:
g_idle_add ((GSourceFunc)ods_imaging_thread_callback, cb_data);
}
static void
ods_imaging_resize_image (OdsImagingCallbackData *cb_data)
{
OdsImageInfo *info;
GdkPixbuf *pixbuf;
gchar *current_encoding = NULL;
gulong current_width = 0;
gulong current_height = 0;
gboolean do_resize;
gboolean do_encode;
const char *format;
struct stat file_stat;
g_message("resize_image thread started");
info = cb_data->data;
g_type_init ();
/* read the image */
pixbuf = ods_imaging_pixbuf_new_with_format (info->filename, ¤t_encoding);
if (pixbuf == NULL)
goto out;
/* get image info and determine what we need to do */
current_width = gdk_pixbuf_get_width (pixbuf);
current_height = gdk_pixbuf_get_height (pixbuf);
do_encode = info->encoding && strcmp (info->encoding, current_encoding);
format = encoding_to_pixbuf_format (info->encoding);
if (format == NULL)
goto out;
do_resize = (info->width != current_width) ||
(info->height != current_height);
/* resize image if needed */
if (do_resize) {
if (info->transformation == ODS_IMAGING_TRANSFORMATION_CROP) {
/* Transformation CROP */
if (info->width > current_width || info->height > current_height)
info->transformation = ODS_IMAGING_TRANSFORMATION_STRETCH;
else {
GdkPixbuf *new;
new = gdk_pixbuf_new_subpixbuf (pixbuf, 0, 0, info->width, info->height);
g_object_unref (pixbuf);
pixbuf = new;
}
} else if (info->transformation == ODS_IMAGING_TRANSFORMATION_FILL) {
/* Transformation FILL */
if (info->width < current_width || info->height < current_height)
info->transformation = ODS_IMAGING_TRANSFORMATION_STRETCH;
else {
GdkPixbuf *blank, *new;
blank = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, info->width, info->height);
new = gdk_pixbuf_add_alpha (blank, FALSE, 0, 0, 0);
g_object_unref (blank);
gdk_pixbuf_fill (new, ODS_IMAGING_FILL_COLOR_RGBA);
gdk_pixbuf_copy_area (pixbuf, 0, 0, current_width, current_height,
new, 0, 0);
g_object_unref (pixbuf);
pixbuf = new;
}
}
if (info->transformation == ODS_IMAGING_TRANSFORMATION_STRETCH) {
GdkPixbuf *new;
new = gdk_pixbuf_scale_simple (pixbuf, info->width, info->height, GDK_INTERP_BILINEAR);
g_object_unref (pixbuf);
pixbuf = new;
}
}
/* write resized/encoded image to file */
if (do_resize || do_encode) {
GError *error = NULL;
gint fd;
fd = g_file_open_tmp (ODS_IMAGING_TEMPNAME,
&(info->resized_image_filename), &error);
if (fd == -1) {
g_clear_error (&error);
g_free (info->resized_image_filename);
info->resized_image_filename = NULL;
goto out;
}
close (fd);
if (gdk_pixbuf_save (pixbuf, info->resized_image_filename, format, NULL, NULL) == FALSE) {
g_free (info->resized_image_filename);
info->resized_image_filename = NULL;
goto out;
}
/* get resized image size */
if (g_stat (info->resized_image_filename, &file_stat) == 0)
info->size = file_stat.st_size;
} else {
/* no operations needed to be done, return original filename */
info->resized_image_filename = g_strdup (info->filename);
}
out:
if (current_encoding)
g_free (current_encoding);
if (pixbuf != NULL)
g_object_unref (pixbuf);
g_idle_add ((GSourceFunc)ods_imaging_thread_callback, cb_data);
g_message ("resize_image thread finished, adding callback to idle");
}
#endif /* USE_GDKPIXBUF */
gboolean
ods_imaging_get_image_info_async (const gchar *filename, OdsImagingFunc func,
gpointer data)
{
#if defined(USE_IMAGEMAGICK) || defined(USE_GDKPIXBUF)
OdsImageInfo *image_info;
OdsImagingCallbackData *cb_data;
image_info = g_new0 (OdsImageInfo, 1);
image_info->filename = g_strdup (filename);
cb_data = g_new0 (OdsImagingCallbackData, 1);
cb_data->func = func;
cb_data->data = image_info;
cb_data->user_data = data;
if (!g_thread_create ((GThreadFunc)ods_imaging_get_image_info,
cb_data, FALSE, NULL)) {
g_warning ("Thread creation failed");
g_free (cb_data->data);
g_free (cb_data);
return FALSE;
}
return TRUE;
#else
return FALSE;
#endif /* USE_IMAGEMAGICK || USE_GDKPIXBUF */
}
/* encoding can be NULL, otherwise it must be UPPERCASE
* transformation can be 0 (no resizing done) */
gboolean
ods_imaging_resize_image_async (const gchar *filename, gulong width, gulong height,
const gchar *encoding, guint transformation,
OdsImagingFunc func, gpointer data)
{
#if defined(USE_IMAGEMAGICK) || defined (USE_GDKPIXBUF)
OdsImageInfo *image_info;
OdsImagingCallbackData *cb_data;
g_message ("resize_image_async");
image_info = g_new0 (OdsImageInfo, 1);
image_info->filename = g_strdup (filename);
image_info->width = width;
image_info->height = height;
if (encoding)
image_info->encoding = g_strdup (encoding);
image_info->transformation = transformation;
cb_data = g_new0 (OdsImagingCallbackData, 1);
cb_data->func = func;
cb_data->data = image_info;
cb_data->user_data = data;
if (!g_thread_create ((GThreadFunc)ods_imaging_resize_image,
cb_data, FALSE, NULL)) {
g_warning ("Thread creation failed");
g_free (cb_data->data);
g_free (cb_data);
return FALSE;
}
return TRUE;
#else
return FALSE;
#endif /* USE_IMAGEMAGICK || USE_GDKPIXBUF */
}
gboolean
ods_imaging_make_image_thumbnail_async (const gchar *filename,
OdsImagingFunc func, gpointer data)
{
return ods_imaging_resize_image_async (filename,
ODS_IMAGING_THUMBNAIL_WIDTH, ODS_IMAGING_THUMBNAIL_HEIGHT,
ODS_IMAGING_THUMBNAIL_ENCODING,
ODS_IMAGING_TRANSFORMATION_STRETCH,
func, data);
}
obex-data-server-0.4.6/src/ods-bluez.h 0000644 0001750 0001750 00000007235 11524724173 014473 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_BLUEZ_H
#define __ODS_BLUEZ_H
#include
#include
/* BIP SDP record bits */
#define BIP_SUPP_CAP_GENERIC_IMAGING (1)
#define BIP_SUPP_CAP_CAPTURING (1 << 1)
#define BIP_SUPP_CAP_PRINTING (1 << 2)
#define BIP_SUPP_CAP_DISPLAYING (1 << 3)
#define BIP_SUPP_FEAT_IMAGE_PUSH (1)
#define BIP_SUPP_FEAT_IMAGE_PUSH_STORE (1 << 1)
#define BIP_SUPP_FEAT_IMAGE_PUSH_PRINT (1 << 2)
#define BIP_SUPP_FEAT_IMAGE_PUSH_DISPLAY (1 << 3)
#define BIP_SUPP_FEAT_IMAGE_PULL (1 << 4)
#define BIP_SUPP_FEAT_ADVANCED_IMAGE_PRINTING (1 << 5)
#define BIP_SUPP_FEAT_AUTOMATIC_ARCHIVE (1 << 6)
#define BIP_SUPP_FEAT_REMOTE_CAMERA (1 << 7)
#define BIP_SUPP_FEAT_REMOTE_DISPLAY (1 << 8)
#define BIP_SUPP_FUNC_GET_CAPABILITIES (1)
#define BIP_SUPP_FUNC_PUT_IMAGE (1 << 1)
#define BIP_SUPP_FUNC_PUT_LINKED_ATTACHMENT (1 << 2)
#define BIP_SUPP_FUNC_PUT_LINKED_THUMBNAIL (1 << 3)
#define BIP_SUPP_FUNC_REMOTE_DISPLAY (1 << 4)
#define BIP_SUPP_FUNC_GET_IMAGES_LIST (1 << 5)
#define BIP_SUPP_FUNC_GET_IMAGE_PROPERTIES (1 << 6)
#define BIP_SUPP_FUNC_GET_IMAGE (1 << 7)
#define BIP_SUPP_FUNC_GET_LINKED_THUMBNAIL (1 << 8)
#define BIP_SUPP_FUNC_GET_LINKED_ATTACHMENT (1 << 9)
#define BIP_SUPP_FUNC_DELETE_IMAGE (1 << 10)
#define BIP_SUPP_FUNC_START_PRINT (1 << 11)
#define BIP_SUPP_FUNC_START_ARCHIVE (1 << 13)
#define BIP_SUPP_FUNC_GET_MONITORING_IMAGE (1 << 14)
#define BIP_SUPP_FUNC_GET_STATUS (1 << 16)
typedef struct ImagingSdpData_ {
guint8 supp_capabilities;
guint16 supp_features;
guint32 supp_functions;
guint64 data_capacity;
} ImagingSdpData;
typedef void (* OdsBluezFunc) (gint, gint, const ImagingSdpData*, GError*, gpointer);
typedef struct OdsBluezCancellable_ {
/* cancellable data */
sdp_session_t *session;
GIOChannel *io_channel;
guint io_watch;
gint fd;/* RFCOMM socket */
/* other data */
OdsBluezFunc cb;
gpointer cb_data;
bdaddr_t target_address;
bdaddr_t source_address;
uuid_t uuid;
guint imaging_feature;
ImagingSdpData *imagingdata;
gint channel;
} OdsBluezCancellable;
OdsBluezCancellable* ods_bluez_get_client_socket (const bdaddr_t *dst,
const bdaddr_t *src,
const uuid_t *uuid,
guint imaging_feature,
gint channel,
OdsBluezFunc func,
gpointer data);
void ods_bluez_cancel_get_client_socket (OdsBluezCancellable *cancel);
gint ods_bluez_get_server_socket (const gchar *address,
guint8 channel);
guint32 ods_bluez_add_service_record (const gchar *device,
gint service,
ImagingSdpData *imagingdata);
void ods_bluez_remove_service_record (const gchar *device,
guint32 record_handle);
void ods_bluez_finalize ();
#endif /* __ODS_BLUEZ_H */
obex-data-server-0.4.6/src/ods-server-session.xml 0000644 0001750 0001750 00000002454 11524724173 016710 0000000 0000000
obex-data-server-0.4.6/src/ods-obex.h 0000644 0001750 0001750 00000020512 11524724173 014300 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_OBEX_H
#define __ODS_OBEX_H
#include
#include
#include
/* FTP CMD_ACTION */
#ifndef OBEX_CMD_ACTION
#define OBEX_CMD_ACTION 0x06
#define OBEX_HDR_ACTION_ID 0x94
#define OBEX_HDR_DESTNAME 0x15
#define OBEX_HDR_PERMISSIONS 0xD6
#define OBEX_ACTION_COPY 0x00
#define OBEX_ACTION_MOVE 0x01
#define OBEX_ACTION_SETPERM 0x02
#endif /* OBEX_CMD_ACTION */
/* CMD_ACTION permissions */
#define OBEX_PERM_READ 1
#define OBEX_PERM_WRITE 1 << 1
#define OBEX_PERM_DEL 1 << 2
#define OBEX_PERM_MODIFY 1 << 7
/* Transfer suspend results */
#define OBEX_SUSP_REJECTED -1
#define OBEX_SUSP_ACCEPTED 1
#define OBEX_SUSP_FIFO_ERR -2
#define OBEX_SUSP_FIFO_ACT 2
/* BIP-specific headers */
#define OBEX_HDR_IMG_DESCRIPTOR 0x71
#define OBEX_HDR_IMG_HANDLE 0x30
/* BIP app-parameters header for RemoteDisplay */
#define BIP_REMOTEDISPLAY_NEXTIMAGE 0x01
#define BIP_REMOTEDISPLAY_PREVIOUSIMAGE 0x02
#define BIP_REMOTEDISPLAY_SELECTIMAGE 0x03
#define BIP_REMOTEDISPLAY_CURRENTIMAGE 0x04
#define BIP_APPARAM_REMOTEDISPLAY_TAGID 0x08
typedef struct bip_apparam_remote_display {
uint8_t tag_id;
uint8_t length;
uint8_t value;
} __attribute__ ((packed)) bip_apparam_remote_display_t;
#define CONID_INVALID 0xFFFFFFFF
#define ODS_DEFAULT_RX_MTU 32767
#define ODS_DEFAULT_TX_MTU 32767
#define ODS_TTY_RX_MTU 65535
#define ODS_TTY_TX_MTU 65535
/* Request timeout (when ods considers request as timed out and kills connection) */
/* in seconds */
#define ODS_OBEX_TIMEOUT 15
#define CAP_TYPE "x-obex/capability"
#define OBP_TYPE "x-obex/object-profile"
#define LST_TYPE "x-obex/folder-listing"
/* BIP-specific object types */
#define BIP_IMG_TYPE "x-bt/img-img"
#define BIP_THM_TYPE "x-bt/img-thm"
#define BIP_ATTACHMENT_TYPE "x-bt/img-attachment"
#define BIP_LISTING_TYPE "x-bt/img-listing"
#define BIP_PROPERTIES_TYPE "x-bt/img-properties"
#define BIP_CAPABILITIES_TYPE "x-bt/img-capabilities"
#define BIP_MONITORING_TYPE "x-bt/img-monitoring"
#define BIP_DISPLAY_TYPE "x-bt/img-display"
#define BIP_PRINT_TYPE "x-bt/img-print"
#define BIP_PARTIAL_TYPE "x-bt/img-partial"
#define BIP_ARCHIVE_TYPE "x-bt/img-archive"
#define BIP_STATUS_TYPE "x-bt/img-status"
typedef struct
{
obex_t *obex_handle;
guint16 tx_max;
guint16 rx_max;
guint32 connection_id;
obex_event_t obex_event;
GIOFunc io_callback;
guint io_watch;
gboolean usb_read_more; /* USB trasport specific (set in session->obex_usbevent) */
/* transfer basic info */
guint8 obex_cmd; /* obex command */
guint timeout_id; /* source id for timeout function (>0 if set) (used for client requests) */
gchar *local;
gchar *remote;
gchar *type;
guint64 target_size;
time_t modtime;
gboolean report_progress;
gboolean transfer_started_signal_emitted;
guint suspend_timeout_id;
gint suspend_result; /* transfers can be suspended for serversession accept/reject or when FIFO pipes are used in sessions */
/* extended info */
gchar *img_handle;/* BIP-specific image handle */
GHashTable *ext_info;/* Any extended info which is not used internally */
/* transfer data */
guchar *buf; /* Data buffer for put and get requests */
guint64 buf_size;
gint stream_fd;
guint fifo_watch;/* used to watch for fifo events */
/* transfer status */
guint64 counter;
gboolean cancelled;
} OdsObexContext;
typedef struct obex_connect_hdr {
uint8_t version;
uint8_t flags;
uint16_t mtu;
} __attribute__ ((packed)) obex_connect_hdr_t;
typedef struct obex_setpath_hdr {
uint8_t flags;
uint8_t constants;
} __attribute__ ((packed)) obex_setpath_hdr_t;
void ods_obex_transfer_new (OdsObexContext *obex_context,
const gchar *local,
const gchar *remote,
const gchar *type);
void ods_obex_transfer_suspend (OdsObexContext *obex_context);
void ods_obex_transfer_close (OdsObexContext *obex_context);
void ods_obex_transfer_add_info (OdsObexContext *obex_context,
gchar *key,
gchar *value);
GHashTable* ods_obex_transfer_get_info (OdsObexContext *obex_context);
OdsObexContext *ods_obex_context_new (void);
gboolean ods_obex_setup_fdtransport (OdsObexContext *obex_context,
gint fd,
guint16 rx_mtu,
guint16 tx_mtu,
obex_event_t eventcb,
GIOFunc io_cb,
gpointer user_data,
GError **error);
gboolean ods_obex_setup_usbtransport (OdsObexContext *obex_context,
gint intf_num,
obex_event_t eventcb,
GIOFunc io_cb,
gpointer user_data,
GError **error);
void ods_obex_close_transport (OdsObexContext *ctxt);
gchar *ods_obex_get_buffer_as_string (OdsObexContext *obex_context);
gboolean ods_obex_srv_new_file (OdsObexContext *obex_context,
const gchar *path);
gint ods_obex_connect_done (OdsObexContext *obex_context,
obex_object_t *object);
gint ods_obex_connect (OdsObexContext *obex_context,
const guchar *uuid,
guint uuid_length);
gint ods_obex_srv_connect (OdsObexContext *obex_context,
obex_object_t *object,
guint service);
gint ods_obex_disconnect (OdsObexContext *obex_context);
gint ods_obex_readstream (OdsObexContext *obex_context,
obex_object_t *object);
gint ods_obex_writestream(OdsObexContext *obex_context,
obex_object_t *object);
gint ods_obex_get (OdsObexContext *obex_context,
const gchar *local,
const gchar *remote,
const gchar *type,
gboolean is_fifo);
gint ods_obex_srv_get (OdsObexContext *obex_context,
obex_object_t *object,
const gchar *current_path,
const gchar *root_path,
gboolean allow_write);
gint ods_obex_put (OdsObexContext *obex_context,
const gchar *local,
const gchar *remote,
const gchar *type,
guint64 size,
time_t mtime,
gboolean is_fifo,
gint fifo_fd);
gint ods_obex_srv_put (OdsObexContext *obex_context,
obex_object_t *object,
const gchar *path,
guint8 *action,
gboolean no_response_on_success);
gint ods_obex_setpath (OdsObexContext *obex_context,
const gchar *path,
gboolean create);
gboolean ods_obex_srv_setpath (OdsObexContext *obex_context,
obex_object_t *object,
const gchar *root_path,
const gchar *current_path,
gchar **new_path,
gboolean allow_write);
gint ods_obex_put_image (OdsObexContext *obex_context,
const gchar *local,
const gchar *remote,
const gchar *encoding,
const gchar *pixel,
guint64 size,
const gchar *transformation);
gint ods_obex_put_linked_thumbnail (OdsObexContext *obex_context,
const gchar *local,
const gchar *img_handle,
guint64 size);
gint ods_obex_put_linked_attachment (OdsObexContext *obex_context,
const gchar *local,
const gchar *img_handle,
const gchar *name,
const gchar *content_type,
const gchar *charset,
guint64 size,
time_t ctime);
gint ods_obex_remote_display (OdsObexContext *obex_context,
const gchar *img_handle,
guint8 action);
gint ods_obex_action (OdsObexContext *obex_context,
const gchar *src,
const gchar *dst,
guint8 action,
guint32 perms);
#endif /* __ODS_OBEX_H */
obex-data-server-0.4.6/src/ods-session.c 0000644 0001750 0001750 00000222750 11524724173 015031 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2009 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "config.h"
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "ods-bluez.h"
#include "ods-common.h"
#include "ods-error.h"
#include "ods-imaging-helpers.h"
#include "ods-manager.h"
#include "ods-marshal.h"
#include "ods-logging.h"
#include "ods-obex.h"
#include "ods-session.h"
#include "ods-session-dbus-glue.h"
static void ods_session_finalize (GObject *object);
static void ods_session_connect_internal (OdsSession *session,
GError **error);
#define ODS_SESSION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), ODS_TYPE_SESSION, OdsSessionPrivate))
#define ODS_SESSION_DBUS_PATH_PATTERN "/org/openobex/session%d"
#define ODS_SESSION_DBUS_INTERFACE "org.openobex.Session"
typedef enum {
ODS_SESSION_STATE_INIT,
ODS_SESSION_STATE_OPEN,
ODS_SESSION_STATE_BUSY,
ODS_SESSION_STATE_NOT_CONNECTED
} OdsSessionState;
typedef struct OdsSessionPutImageData_ {
OdsSession *session;
DBusGMethodInvocation *context;
gchar *img_handle;
gboolean only_get_info;
} OdsSessionPutImageData;
struct OdsSessionPrivate {
/* constructor properties */
gint fd; /* rfcomm device */
guint service;
gchar *owner; /* D-Bus client, who initiated this session */
guchar *target_uuid; /* Target UUID used for CMD_CONNECT */
gint usbintfnum; /* USB interface number */
/* state variables */
OdsSessionState state; /* ODS_SESSION_STATE_INIT by default */
/* OBEX connection */
OdsObexContext *obex_context;
/* other */
GStaticMutex mutex;
DBusGMethodInvocation *dbus_context; /* D-Bus context for async methods */
gchar *dbus_path; /* D-Bus path for this object */
gchar *current_path; /* Current path on remote device */
gchar *new_path; /* Temporarily stored new path on remote device */
gint transfer_hint_fifo;
gchar *transfer_hint_name;
gchar *transfer_hint_type;
guint64 transfer_hint_size;
gint64 transfer_hint_mtime;
gint64 transfer_hint_ctime;
/* BIP-specific */
guint imaging_feature;
ImagingSdpData *imaging_sdp_data;
};
enum {
CANCELLED,
CONNECT_RESULT_INTERNAL,
DISCONNECTED,
CLOSED,
TRANSFER_STARTED,
TRANSFER_PROGRESS,
TRANSFER_COMPLETED,
ERROR_OCCURRED,
IMAGE_HANDLE_RECEIVED,
LAST_SIGNAL
};
static guint signals [LAST_SIGNAL] = { 0, };
/* for numbering established sessions */
static guint iterator = 0;
G_DEFINE_TYPE (OdsSession, ods_session, G_TYPE_OBJECT)
static void
session_log (OdsSession *session, GLogLevelFlags log_level, const gchar *message, ...)
{
va_list args;
gchar *format = NULL;
va_start (args, message);
if (session->priv->dbus_path) {
format = g_strdup_printf("%s: %s", session->priv->dbus_path, message);
g_logv (G_LOG_DOMAIN, log_level, format, args);
g_free (format);
}
else {
g_logv (G_LOG_DOMAIN, log_level, message, args);
}
va_end (args);
}
#define session_message(session, format, ...) session_log (session, G_LOG_LEVEL_MESSAGE, format, ##__VA_ARGS__)
#define session_warning(session, format, ...) session_log (session, G_LOG_LEVEL_WARNING, format, ##__VA_ARGS__)
#define ODS_SESSION_LOCK(session) session_log (session, G_LOG_LEVEL_MESSAGE, "LOCK %s", __FUNCTION__); g_static_mutex_lock (&(session)->priv->mutex)
#define ODS_SESSION_UNLOCK(session) session_log (session, G_LOG_LEVEL_MESSAGE, "UNLOCK %s", __FUNCTION__); g_static_mutex_unlock (&(session)->priv->mutex)
static void
emit_connect_result_internal (OdsSession *session, GError *error)
{
gchar *error_name;
if (error) {
ods_obex_close_transport (session->priv->obex_context);
error_name = ods_error_get_dbus_name (error);
g_signal_emit (session, signals [CONNECT_RESULT_INTERNAL], 0,
error_name, error->message);
g_free (error_name);
} else {
g_signal_emit (session, signals [CONNECT_RESULT_INTERNAL], 0,
NULL, NULL);
}
}
static gboolean
local_file_test (const gchar *local_path, gboolean *is_fifo)
{
gboolean ret;
/* Check if this is regular file or symlink pointing to regular file */
ret = g_file_test (local_path, G_FILE_TEST_IS_REGULAR);
/* Check if it is a FIFO */
*is_fifo = FALSE;
if (!ret) {
struct stat s;
if (g_stat (local_path, &s) == 0 && S_ISFIFO (s.st_mode)) {
*is_fifo = TRUE;
ret = TRUE;
}
}
return ret;
}
static gboolean
emit_disconnected (OdsSession *session)
{
ods_obex_close_transport (session->priv->obex_context);
g_signal_emit (session, signals [DISCONNECTED], 0);
return FALSE;
}
static gboolean
obex_io_callback (GIOChannel *io_channel, GIOCondition cond, gpointer data)
{
obex_t *obex_handle;
OdsSession *session;
GError *error = NULL;
gboolean ret = TRUE;
obex_handle = (obex_t *) data;
session = ODS_SESSION (OBEX_GetUserData (obex_handle));
session_message (session, "io callback");
if (cond & (G_IO_ERR | G_IO_HUP | G_IO_NVAL)) {
if (session->priv->state == ODS_SESSION_STATE_INIT) {
/* Link error happened while establishing OBEX connection,
* hence emit ConnectResultInternal here (no need to emit
* Disconnected signal) */
g_set_error (&error, ODS_ERROR, ODS_ERROR_LINK_ERROR,
"Lost connection");
emit_connect_result_internal (session, error);
g_clear_error (&error);
return FALSE;
}
/* emit Disconnected for all other states */
g_idle_add ((GSourceFunc) emit_disconnected, session);
if (session->priv->state == ODS_SESSION_STATE_NOT_CONNECTED) {
/* CMD_DISCONNECT was sent but did not receive proper reply,
* don't emit ErrorOccurred */
return FALSE;
}
g_set_error (&error, ODS_ERROR, ODS_ERROR_LINK_ERROR, "Connection error");
/* cleanup transfer data and set state to NOT_CONNECTED */
/* If it was GET operation, remove incomplete file */
if (session->priv->obex_context->obex_cmd == OBEX_CMD_GET &&
session->priv->obex_context->stream_fd >= 0)
g_unlink (session->priv->obex_context->local);
ods_obex_transfer_close (session->priv->obex_context);
session->priv->state = ODS_SESSION_STATE_NOT_CONNECTED;
/* Return D-Bus context, unlock mutex */
if (session->priv->dbus_context) {
dbus_g_method_return_error (session->priv->dbus_context, error);
session->priv->dbus_context = NULL;
ODS_SESSION_UNLOCK (session);
}
ret = FALSE;
} else if (OBEX_HandleInput (obex_handle, 1) < 0) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_BAD_DATA,
"Could not parse incoming data");
}
if (error) {
gchar *error_name;
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred signal */
g_signal_emit (session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
}
return ret;
}
static void
reset_transfer_hints (OdsSession *session)
{
session->priv->transfer_hint_fifo = -1;
g_free (session->priv->transfer_hint_name);
session->priv->transfer_hint_name = NULL;
g_free (session->priv->transfer_hint_type);
session->priv->transfer_hint_type = NULL;
session->priv->transfer_hint_size = 0;
session->priv->transfer_hint_mtime = -1;
session->priv->transfer_hint_ctime = -1;
}
static void
obex_transfer_done (OdsSession *session, gint response)
{
GError *error = NULL;
gchar *error_name;
session->priv->state = ODS_SESSION_STATE_OPEN;
if (response != OBEX_RSP_SUCCESS && response != OBEX_RSP_PARTIAL_CONTENT) {
/* get GError corresponding to OBEX response code */
ods_error_obexrsp2gerror (response, &error);
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred Signal */
g_signal_emit (session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
return;
}
if (session->priv->obex_context->report_progress) {
/* emit signals */
g_signal_emit (session, signals [TRANSFER_PROGRESS], 0,
session->priv->obex_context->target_size);
g_signal_emit (session, signals [TRANSFER_COMPLETED], 0);
}
}
static void
obex_transfer_data_exchange_done (OdsSession *session, gint ret)
{
GError *error = NULL;
gchar *error_name;
OdsObexContext *obex_context;
obex_context = session->priv->obex_context;
if (ret < 0) {
ods_error_err2gerror (ret, &error);
/* Get D-Bus name for error */
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred Signal */
g_signal_emit (session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
/* Reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
} else if (ret == 0 && obex_context->report_progress &&
!obex_context->transfer_started_signal_emitted) {
g_signal_emit (session, signals [TRANSFER_STARTED], 0,
obex_context->remote,
obex_context->local,
obex_context->target_size);
obex_context->transfer_started_signal_emitted = TRUE;
}
}
static void
make_thumbnail_cb (OdsImageInfo *info, OdsSessionPutImageData *data)
{
GError *error = NULL;
gchar *error_name;
gint ret;
if (!info->resized_image_filename) {
/* Could not make thumbnail */
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not make image thumbnail");
goto out;
}
ret = ods_obex_put_linked_thumbnail (data->session->priv->obex_context,
info->resized_image_filename,
data->img_handle, info->size);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
goto out;
}
out:
if (error) {
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred Signal */
g_signal_emit (data->session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
/* reset state */
data->session->priv->state = ODS_SESSION_STATE_OPEN;
}
g_free (data->img_handle);
g_free (data);
ods_image_info_free (info);
}
static void
obex_request_done (OdsSession *session, obex_object_t *object, int command,
int response)
{
GError *error = NULL;
OdsObexContext *obex_context;
/* for CMD_PUT only */
obex_headerdata_t hv;
uint8_t hi;
guint hlen;
gchar *img_handle = NULL;
OdsSessionPutImageData *cb_data;
gchar *error_name;
gchar *local_path = NULL;
session_message (session, "obex_request_done: command %d, response %d (%s)",
command, response, OBEX_ResponseToString (response));
obex_context = session->priv->obex_context;
switch (command) {
case OBEX_CMD_CONNECT:
if (response == OBEX_RSP_SUCCESS) {
ods_obex_connect_done (obex_context, object);
/* update state */
session->priv->state = ODS_SESSION_STATE_OPEN;
emit_connect_result_internal (session, NULL);
} else {
g_set_error (&error, ODS_ERROR, ODS_ERROR_CONNECTION_REFUSED,
"Remote device refused connection");
emit_connect_result_internal (session, error);
g_clear_error (&error);
}
break;
case OBEX_CMD_DISCONNECT:
g_idle_add ((GSourceFunc) emit_disconnected, session);
break;
case OBEX_CMD_SETPATH:
/* check response code here */
if (response == OBEX_RSP_NOT_FOUND) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_FOUND,
"Path not found");
if (session->priv->dbus_context) {
dbus_g_method_return_error (session->priv->dbus_context,
error);
session->priv->dbus_context = NULL;
}
g_clear_error (&error);
} else if (response == OBEX_RSP_SUCCESS) {
gchar *temp;
if (!strcmp (session->priv->new_path, ""))
temp = g_strdup ("/");
else if (!strcmp (session->priv->new_path, "..")) {
gchar *temp2;
/* get rid of trailing "/" */
session->priv->current_path[
strlen (session->priv->current_path)-1] = 0;
temp2 = g_path_get_dirname (session->priv->current_path);
/* add trailing "/" */
temp = g_strdup_printf ("%s/", temp2);
g_free (temp2);
} else {
gchar *first_element;
/* make sure we don't leave "/" in the beginning */
if (session->priv->current_path[0] == '/')
first_element = "";
else
first_element = session->priv->current_path;
temp = g_strdup_printf ("%s%s/", first_element,
session->priv->new_path);
}
g_free (session->priv->current_path);
session->priv->current_path = temp;
if (session->priv->dbus_context) {
dbus_g_method_return (session->priv->dbus_context);
session->priv->dbus_context = NULL;
}
} else {/* some other response code, must be error */
/* get GError corresponding to OBEX response code */
ods_error_obexrsp2gerror (response, &error);
dbus_g_method_return_error (session->priv->dbus_context, error);
session->priv->dbus_context = NULL;
g_clear_error (&error);
}
ODS_SESSION_UNLOCK (session);
break;
case OBEX_CMD_ACTION:
if (response == OBEX_RSP_SUCCESS) {
if (session->priv->dbus_context) {
dbus_g_method_return (session->priv->dbus_context);
session->priv->dbus_context = NULL;
}
} else {
/* get GError corresponding to OBEX response code */
ods_error_obexrsp2gerror (response, &error);
dbus_g_method_return_error (session->priv->dbus_context, error);
session->priv->dbus_context = NULL;
g_clear_error (&error);
}
ODS_SESSION_UNLOCK (session);
break;
case OBEX_CMD_PUT:
if (!obex_context->report_progress) {
/* DeleteRemoteFile or RemoteDisplay* was executed */
session->priv->state = ODS_SESSION_STATE_OPEN;
if (session->priv->dbus_context) {
if (response != OBEX_RSP_SUCCESS) {
/* get GError corresponding to OBEX response code */
ods_error_obexrsp2gerror (response, &error);
dbus_g_method_return_error (session->priv->dbus_context,
error);
session->priv->dbus_context = NULL;
g_clear_error (&error);
} else {
dbus_g_method_return (session->priv->dbus_context);
session->priv->dbus_context = NULL;
}
ODS_SESSION_UNLOCK (session);
}
} else {
/* Check for img-handle header (in case of BIP PutImage) */
while (OBEX_ObjectGetNextHeader(obex_context->obex_handle,
object, &hi, &hv, &hlen)) {
if (hi == OBEX_HDR_IMG_HANDLE) {
img_handle = ods_filename_from_utf16 ((gchar *) hv.bs,
hlen);
g_signal_emit (session, signals [IMAGE_HANDLE_RECEIVED],
0, img_handle, response==OBEX_RSP_PARTIAL_CONTENT);
if (response == OBEX_RSP_PARTIAL_CONTENT) {
/* save local_path */
local_path = g_strdup (obex_context->local);
}
}
}
/* finish transfer (emit signals) */
obex_transfer_done (session, response);
}
ods_obex_transfer_close (obex_context);
if (img_handle && response==OBEX_RSP_PARTIAL_CONTENT) {
/* Responder requested thumbnail, let's send it */
session->priv->state = ODS_SESSION_STATE_BUSY;
cb_data = g_new0 (OdsSessionPutImageData, 1);
cb_data->session = session;
cb_data->img_handle = g_strdup (img_handle);
if (!ods_imaging_make_image_thumbnail_async (local_path,
(OdsImagingFunc)make_thumbnail_cb, cb_data)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not create thread");
error_name = ods_error_get_dbus_name (error);
/* emit ErrorOccurred Signal */
g_signal_emit (session, signals [ERROR_OCCURRED], 0,
error_name, error->message);
g_free (error_name);
g_clear_error (&error);
g_free (cb_data->img_handle);
g_free (cb_data);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
}
}
if (img_handle)
g_free (img_handle);
if (local_path)
g_free (local_path);
break;
case OBEX_CMD_GET:
if (!obex_context->report_progress) {
/* RetrieveFolderListing, GetCapability or GetImagingCapabilities
* was executed */
session->priv->state = ODS_SESSION_STATE_OPEN;
if (session->priv->dbus_context) {
if (response != OBEX_RSP_SUCCESS) {
/* get GError corresponding to OBEX response code */
ods_error_obexrsp2gerror (response, &error);
dbus_g_method_return_error (session->priv->dbus_context,
error);
session->priv->dbus_context = NULL;
g_clear_error (&error);
} else {
gchar *buf;
buf = g_strdup (ods_obex_get_buffer_as_string (obex_context));
dbus_g_method_return (session->priv->dbus_context, buf);
g_free (buf);
session->priv->dbus_context = NULL;
}
ODS_SESSION_UNLOCK (session);
}
} else {
obex_transfer_done (session, response);
/* change modification time for received file */
if (obex_context->local) {
session_warning (session, "MODTIME: %d", (gint)obex_context->modtime);
if (obex_context->modtime != -1) {
struct utimbuf ubuf;
ubuf.actime = time (NULL);
ubuf.modtime = obex_context->modtime;
if (utime (obex_context->local, &ubuf) < 0)
session_warning (session, "Invalid modification time");
}
}
}
ods_obex_transfer_close (obex_context);
break;
case OBEX_CMD_SESSION:
break;
}
}
static void
obex_request_cancelled (OdsSession *session, OdsObexContext *obex_context)
{
/* Cleanup transfer data and reset state */
/* If it was GET operation, remove incomplete file */
if (obex_context->obex_cmd == OBEX_CMD_GET &&
obex_context->stream_fd >= 0)
g_unlink (obex_context->local);
ods_obex_transfer_close (obex_context);
session->priv->state = ODS_SESSION_STATE_OPEN;
/* Emit Cancelled signal */
g_signal_emit (session, signals [CANCELLED], 0);
/* In case this was trigerred by Cancel method */
if (session->priv->dbus_context) {
dbus_g_method_return (session->priv->dbus_context);
session->priv->dbus_context = NULL;
ODS_SESSION_UNLOCK (session);
}
}
static void
obex_event (obex_t *handle, obex_object_t *object, int mode, int event,
int command, int response)
{
OdsSession *session;
OdsObexContext *obex_context;
gint ret;
session = ODS_SESSION (OBEX_GetUserData (handle));
obex_context = session->priv->obex_context;
ods_log_obex (session->priv->dbus_path, event, command, response);
switch (event) {
case OBEX_EV_PROGRESS:
if (obex_context->report_progress) {
g_signal_emit (session, signals [TRANSFER_PROGRESS], 0,
obex_context->counter);
session_warning (session, "PROGRESS: %" G_GUINT64_FORMAT, obex_context->counter);
}
break;
case OBEX_EV_REQHINT:
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED, response);
break;
case OBEX_EV_REQ:
OBEX_ObjectSetRsp (object, OBEX_RSP_NOT_IMPLEMENTED, response);
break;
case OBEX_EV_REQDONE:
obex_request_done (session, object, command, response);
break;
case OBEX_EV_PARSEERR:
session_warning (session, "EV_PARSEERR");
break;
case OBEX_EV_ACCEPTHINT:
session_warning (session, "EV_ACCEPTHINT");
break;
case OBEX_EV_LINKERR:
/* we will get LINKERR when Cancel was called, but device didn't
* send OBEX_RSP_SUCCESS response (might be OBEX_RSP_BAD_REQUEST).
* When link error really happens, it is handled in io_callback */
session_warning (session, "EV_LINKERR");
/* go through to ABORT actions */
case OBEX_EV_ABORT:
session_message (session, "EV_ABORT");
obex_request_cancelled (session, obex_context);
break;
case OBEX_EV_STREAMEMPTY:
ret = ods_obex_writestream (obex_context, object);
obex_transfer_data_exchange_done (session, ret);
break;
case OBEX_EV_STREAMAVAIL:
ret = ods_obex_readstream (obex_context, object);
obex_transfer_data_exchange_done (session, ret);
if (ret == 2) {
/* Transfer was cancelled by sending RSP_FORBIDDEN, this will
* not trigger EV_ABORT so we need to emit Cancelled signal here */
obex_request_cancelled (session, obex_context);
}
break;
case OBEX_EV_UNEXPECTED:
case OBEX_EV_REQCHECK:
break;
}
}
static void
obex_usbevent (obex_t *handle, obex_object_t *object, int mode, int event,
int command, int response)
{
OdsSession *session;
OdsObexContext *ctxt;
session = ODS_SESSION (OBEX_GetUserData (handle));
ctxt = session->priv->obex_context;
obex_event (handle, object, mode, event, command, response);
if (event == OBEX_EV_PROGRESS ||
event == OBEX_EV_STREAMEMPTY ||
event == OBEX_EV_STREAMAVAIL)
ctxt->usb_read_more = TRUE; /* There is more data to read */
else
ctxt->usb_read_more = FALSE;
}
static gboolean
ods_session_check_state (OdsSession *session, DBusGMethodInvocation *context)
{
GError *error = NULL;
/* check if connected */
if (session->priv->state == ODS_SESSION_STATE_INIT ||
session->priv->state == ODS_SESSION_STATE_NOT_CONNECTED) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_CONNECTED,
"Not connected");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* check if busy */
if (session->priv->state == ODS_SESSION_STATE_BUSY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_BUSY,
"Another operation in progress");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
return TRUE;
}
static void
ods_session_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
OdsSession *self = (OdsSession *) object;
OdsObexContext *obex_context = self->priv->obex_context;
ImagingSdpData *imaging_data;
guchar *target_uuid;
GError *error = NULL;
switch (property_id) {
case ODS_SESSION_FD:
self->priv->fd = g_value_get_int (value);
if (self->priv->fd >= 0) {
if (ods_obex_setup_fdtransport (
obex_context, self->priv->fd,
ODS_DEFAULT_RX_MTU, ODS_DEFAULT_TX_MTU,
obex_event, obex_io_callback,
self, &error)) {
/* connect automatically */
ods_session_connect_internal (self, &error);
}
if (error) {
emit_connect_result_internal (self, error);
g_clear_error (&error);
}
}
break;
case ODS_SESSION_SERVICE:
self->priv->service = g_value_get_int (value);
break;
case ODS_SESSION_OWNER:
self->priv->owner = g_value_dup_string (value);
break;
case ODS_SESSION_IMAGING_FEATURE:
self->priv->imaging_feature = g_value_get_int (value);
break;
case ODS_SESSION_IMAGING_SDP_DATA:
imaging_data = g_value_get_pointer (value);
self->priv->imaging_sdp_data = g_new0 (ImagingSdpData, 1);
memcpy (self->priv->imaging_sdp_data, imaging_data,
sizeof (ImagingSdpData));
break;
case ODS_SESSION_TARGET_UUID:
target_uuid = g_value_get_pointer (value);
if (target_uuid) {
self->priv->target_uuid = g_malloc0 (OBEX_UUID_LEN);
memcpy (self->priv->target_uuid, target_uuid, OBEX_UUID_LEN);
}
break;
case ODS_SESSION_USBINTFNUM:
self->priv->usbintfnum = g_value_get_int (value);
if (self->priv->usbintfnum >= 0) {
if (ods_obex_setup_usbtransport (obex_context,
self->priv->usbintfnum, obex_usbevent,
obex_io_callback, self, &error)) {
/* connect automatically */
ods_session_connect_internal (self, &error);
}
if (error) {
emit_connect_result_internal (self, error);
g_clear_error (&error);
}
}
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
break;
}
}
static void
ods_session_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
OdsSession *self = (OdsSession *) object;
switch (property_id) {
case ODS_SESSION_FD:
g_value_set_int (value, self->priv->fd);
break;
case ODS_SESSION_SERVICE:
g_value_set_int (value, self->priv->service);
break;
case ODS_SESSION_OWNER:
g_value_set_string (value, self->priv->owner);
break;
case ODS_SESSION_DBUS_PATH:
g_value_set_string (value, self->priv->dbus_path);
break;
case ODS_SESSION_IMAGING_FEATURE:
g_value_set_int (value, self->priv->imaging_feature);
break;
case ODS_SESSION_IMAGING_SDP_DATA:
g_value_set_pointer (value, self->priv->imaging_sdp_data);
break;
case ODS_SESSION_TARGET_UUID:
g_value_set_pointer (value, self->priv->target_uuid);
break;
case ODS_SESSION_USBINTFNUM:
g_value_set_int (value, self->priv->usbintfnum);
break;
default:
/* We don't have any other property... */
G_OBJECT_WARN_INVALID_PROPERTY_ID(object,property_id,pspec);
break;
}
}
/**
* ods_session_class_init:
* @klass: The OdsSessionClass
**/
static void
ods_session_class_init (OdsSessionClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = ods_session_finalize;
object_class->set_property = ods_session_set_property;
object_class->get_property = ods_session_get_property;
g_object_class_install_property (object_class,
ODS_SESSION_FD,
g_param_spec_int ("fd",
"", "",
-1, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_SERVICE,
g_param_spec_int ("service",
"", "",
0, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_OWNER,
g_param_spec_string ("owner",
"", "",
"" /* default value */,
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_DBUS_PATH,
g_param_spec_string ("dbus-path",
"", "",
"" /* default value */,
G_PARAM_READABLE));
g_object_class_install_property (object_class,
ODS_SESSION_IMAGING_FEATURE,
g_param_spec_int ("imaging-feature",
"", "",
0, G_MAXINT, /* min, max values */
0 /* default value */,
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_IMAGING_SDP_DATA,
g_param_spec_pointer ("imaging-sdp-data",
"", "",
G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_TARGET_UUID,
g_param_spec_pointer ("target-uuid",
"", "",
G_PARAM_CONSTRUCT_ONLY | G_PARAM_READWRITE));
g_object_class_install_property (object_class,
ODS_SESSION_USBINTFNUM,
g_param_spec_int ("usbintfnum",
"", "",
G_MININT, G_MAXINT, /* min, max values */
-1 /* default value */,
G_PARAM_READWRITE));
signals [CANCELLED] =
g_signal_new ("cancelled",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, cancelled),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [CONNECT_RESULT_INTERNAL] =
g_signal_new ("connect-result-internal",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, connect_result_internal),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
signals [DISCONNECTED] =
g_signal_new ("disconnected",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, disconnected),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [CLOSED] =
g_signal_new ("closed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, closed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [TRANSFER_STARTED] =
g_signal_new ("transfer-started",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, transfer_started),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING_UINT64,
G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64);
signals [TRANSFER_PROGRESS] =
g_signal_new ("transfer-progress",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, transfer_progress),
NULL,
NULL,
ods_marshal_VOID__UINT64,
G_TYPE_NONE, 1, G_TYPE_UINT64);
signals [TRANSFER_COMPLETED] =
g_signal_new ("transfer-completed",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, transfer_completed),
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals [ERROR_OCCURRED] =
g_signal_new ("error-occurred",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, error_occurred),
NULL,
NULL,
ods_marshal_VOID__STRING_STRING,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_STRING);
signals [IMAGE_HANDLE_RECEIVED] =
g_signal_new ("image-handle-received",
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (OdsSessionClass, image_handle_received),
NULL,
NULL,
ods_marshal_VOID__STRING_BOOLEAN,
G_TYPE_NONE, 2, G_TYPE_STRING, G_TYPE_BOOLEAN);
g_type_class_add_private (klass, sizeof (OdsSessionPrivate));
GError *error = NULL;
/* Init the DBus connection, per-klass */
klass->connection = dbus_g_bus_get (ODS_DBUS_BUS, &error);
if (klass->connection == NULL) {
g_warning("Unable to connect to dbus: %s", error->message);
g_clear_error (&error);
return;
}
/* &dbus_glib_ods_session_object_info is provided in the
* dbus/ods-session-dbus-glue.h file */
dbus_g_object_type_install_info (ODS_TYPE_SESSION, &dbus_glib_ods_session_object_info);
}
/**
* ods_session_init:
* @session: This class instance
**/
static void
ods_session_init (OdsSession *session)
{
OdsSessionClass *klass = ODS_SESSION_GET_CLASS (session);
session->priv = ODS_SESSION_GET_PRIVATE (session);
/* initial priv values */
session->priv->state = ODS_SESSION_STATE_INIT;
session->priv->current_path = g_strdup ("/");
session->priv->transfer_hint_fifo = -1;
session->priv->transfer_hint_ctime = -1;
session->priv->transfer_hint_mtime = -1;
session->priv->obex_context = ods_obex_context_new ();
/* figure out DBus object path for this instance */
session->priv->dbus_path = g_strdup_printf (ODS_SESSION_DBUS_PATH_PATTERN,
iterator);
iterator++;
/* create mutex */
g_static_mutex_init (&session->priv->mutex);
dbus_g_connection_register_g_object (klass->connection,
session->priv->dbus_path,
G_OBJECT (session));
}
/**
* ods_session_finalize:
* @object: The object to finalize
*
* Finalize the session
**/
static void
ods_session_finalize (GObject *object)
{
OdsSession *session;
g_return_if_fail (object != NULL);
g_return_if_fail (ODS_IS_SESSION (object));
session = ODS_SESSION (object);
g_return_if_fail (session->priv != NULL);
/* close connection, free obex_context */
ods_obex_close_transport (session->priv->obex_context);
if (session->priv->fd != -1) {
session_message (session, "closing connection");
close (session->priv->fd);
}
OBEX_Cleanup (session->priv->obex_context->obex_handle);
g_free (session->priv->obex_context);
/* free other private variables */
g_free (session->priv->owner);
g_free (session->priv->dbus_path);
g_free (session->priv->imaging_sdp_data);
g_free (session->priv->target_uuid);
if (session->priv->new_path)
g_free (session->priv->new_path);
g_free (session->priv->current_path);
g_free (session->priv->transfer_hint_name);
g_free (session->priv->transfer_hint_type);
g_static_mutex_free (&session->priv->mutex);
G_OBJECT_CLASS (ods_session_parent_class)->finalize (object);
}
/**
* ods_session_new:
*
* Return value: a new OdsSession object.
**/
OdsSession *
ods_session_new (gint fd, gint usb_interface_number, gint service,
const gchar *owner,
const gchar *target_uuid)
{
OdsSession *session;
session = g_object_new (ODS_TYPE_SESSION,
"fd", fd,
"usbintfnum", usb_interface_number,
"service", service,
"owner", owner,
"target-uuid", target_uuid,
NULL);
return ODS_SESSION (session);
}
static void
ods_session_connect_internal (OdsSession *session, GError **error)
{
guchar *uuid = NULL;
guint uuid_length = 0;
gint ret;
if (session->priv->state != ODS_SESSION_STATE_INIT)
return;
if (session->priv->target_uuid) {
uuid = session->priv->target_uuid;
uuid_length = OBEX_UUID_LEN;
}
/* send obex connect command */
ret = ods_obex_connect (session->priv->obex_context, uuid, uuid_length);
if (ret < 0)
ods_error_err2gerror (ret, error);
}
gint
ods_session_disconnect_internal (OdsSession *session, GError **error)
{
gint ret;
if (session->priv->state == ODS_SESSION_STATE_NOT_CONNECTED) {
/* emit DISCONNECTED signal now */
g_idle_add ((GSourceFunc) emit_disconnected, session);
return 1;
}
/* actually disconnect */
session->priv->state = ODS_SESSION_STATE_NOT_CONNECTED;
ret = ods_obex_disconnect (session->priv->obex_context);
if (ret < 0) {
/* emit DISCONNECTED signal now and set state to NOT_CONNECTED
* in this case disconnection will happen when socket is closed */
g_idle_add ((GSourceFunc) emit_disconnected, session);
ods_error_err2gerror (ret, error);
return -1;
}
return 0;
}
gboolean
ods_session_disconnect (OdsSession *session, DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->state == ODS_SESSION_STATE_INIT)
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_AUTHORIZED,
"Session is still being connected, Cancel connection instead");
else if (session->priv->state == ODS_SESSION_STATE_BUSY)
g_set_error (&error, ODS_ERROR, ODS_ERROR_BUSY,
"Operations in progress need to be cancelled first");
if (error) {
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
ret = ods_session_disconnect_internal (session, &error);
if (ret == -1) {
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
} else {
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
}
return TRUE;
}
gboolean
ods_session_close (OdsSession *session, DBusGMethodInvocation *context)
{
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->state == ODS_SESSION_STATE_INIT)
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_AUTHORIZED,
"Session is still being connected, Cancel connection instead");
else if (session->priv->state != ODS_SESSION_STATE_NOT_CONNECTED)
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Need to disconnect first");
if (error) {
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* emit CLOSED signal; manager will finalize this object */
ODS_SESSION_UNLOCK (session);
g_signal_emit (session, signals[CLOSED], 0);
dbus_g_method_return (context);
return TRUE;
}
static gboolean
ods_session_setpath (OdsSession *session, const gchar *path, gboolean create,
DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
OdsObexContext *obex_context = session->priv->obex_context;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_GOEP &&
session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* validate path */
if (strchr (path, '/')) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid character in path ('/')");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->dbus_context) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
/* copy new path to temporary variable */
if (session->priv->new_path)
g_free (session->priv->new_path);
session->priv->new_path = g_strdup (path);
/* change the folder */
ret = ods_obex_setpath (obex_context, path, create);
if (ret < 0) {
ods_error_err2gerror(ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
/* reset state */
session->priv->dbus_context = NULL;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
gboolean
ods_session_change_current_folder (OdsSession *session, const gchar *path,
DBusGMethodInvocation *context)
{
return ods_session_setpath (session, path, FALSE, context);
}
gboolean
ods_session_change_current_folder_backward (OdsSession *session,
DBusGMethodInvocation *context)
{
return ods_session_setpath (session, "..", FALSE, context);
}
gboolean
ods_session_change_current_folder_to_root (OdsSession *session,
DBusGMethodInvocation *context)
{
return ods_session_setpath (session, "", FALSE, context);
}
gchar *
ods_session_get_current_path (OdsSession *session)
{
return g_strdup (session->priv->current_path);
}
static gboolean
ods_session_copy_remote_file_full (OdsSession *session,
const gchar *remote_filename,
const gchar *type,
const gchar *local_path,
DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
gboolean is_fifo;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_GOEP &&
session->priv->service != ODS_SERVICE_OPP &&
session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* validate remote_filename */
if (remote_filename &&
(*remote_filename == '\0' || strchr (remote_filename, '/'))) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid remote filename");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* validate type */
if (type && *type == '\0') {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid type");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* validate local path */
if (*local_path == '\0') {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
local_file_test (local_path, &is_fifo); /* non existent path is also OK, it'll be created */
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_get (session->priv->obex_context, local_path,
remote_filename, type, is_fifo);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* return immediately, user will get transfer progress and completion signals */
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
return TRUE;
}
gboolean
ods_session_copy_remote_file (OdsSession *session,
const gchar *remote_filename,
const gchar *local_path,
DBusGMethodInvocation *context)
{
return ods_session_copy_remote_file_full (session, remote_filename, NULL,
local_path, context);
}
gboolean
ods_session_copy_remote_file_by_type (OdsSession *session,
const gchar *type,
const gchar *local_path,
DBusGMethodInvocation *context)
{
return ods_session_copy_remote_file_full (session, NULL, type,
local_path, context);
}
gboolean
ods_session_create_folder (OdsSession *session,
const gchar *folder_name,
DBusGMethodInvocation *context)
{
return ods_session_setpath (session, folder_name, TRUE, context);
}
static gboolean
ods_session_get_by_type (OdsSession *session, DBusGMethodInvocation *context,
const gchar *type)
{
gint ret;
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->dbus_context) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_get (session->priv->obex_context, NULL, NULL, type, FALSE);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
session->priv->dbus_context = NULL;
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
gboolean
ods_session_retrieve_folder_listing (OdsSession *session,
DBusGMethodInvocation *context)
{
GError *error = NULL;
if (session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
return ods_session_get_by_type (session, context, LST_TYPE);
}
gboolean
ods_session_get_capability (OdsSession *session, DBusGMethodInvocation *context)
{
GError *error = NULL;
if (session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
return ods_session_get_by_type (session, context, CAP_TYPE);
}
gboolean
ods_session_get_imaging_capabilities (OdsSession *session,
DBusGMethodInvocation *context)
{
GError *error = NULL;
if (session->priv->service != ODS_SERVICE_BIP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
return ods_session_get_by_type (session, context, BIP_CAPABILITIES_TYPE);
}
gboolean
ods_session_send_file_ext (OdsSession *session, const gchar *local_path,
const gchar *remote_filename, const gchar *type,
DBusGMethodInvocation *context)
{
gint ret;
gchar *basename = NULL;
const gchar *remote_used = NULL;
const gchar *type_used = NULL;
GError *error = NULL;
gboolean is_fifo;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_GOEP &&
session->priv->service != ODS_SERVICE_OPP &&
session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!local_file_test (local_path, &is_fifo)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
return FALSE;
}
/* Figure out if we have to use different remote_filename and type */
if (*remote_filename != '\0') {
g_free (session->priv->transfer_hint_name);
session->priv->transfer_hint_name = g_strdup (remote_filename);
}
if (session->priv->transfer_hint_name)
remote_used = session->priv->transfer_hint_name;
else {
basename = g_path_get_basename (local_path);
remote_used = basename;
}
if (*type != '\0') {
g_free (session->priv->transfer_hint_type);
session->priv->transfer_hint_type = g_strdup (type);
}
if (session->priv->transfer_hint_type)
type_used = session->priv->transfer_hint_type;
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_put (session->priv->obex_context, local_path,
remote_used, type_used,
session->priv->transfer_hint_size,
session->priv->transfer_hint_mtime,
is_fifo, session->priv->transfer_hint_fifo);
g_free (basename);
reset_transfer_hints (session);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* return immediately, user will get transfer progress and completion signals */
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
return TRUE;
}
gboolean
ods_session_send_file (OdsSession *session,
const gchar *local_path,
DBusGMethodInvocation *context)
{
return ods_session_send_file_ext (session, local_path, "", "", context);
}
gboolean
ods_session_set_transfer_hints (OdsSession *session,
const gchar *fifo,
const gchar *remote_filename,
const gchar *type, guint64 size,
gint64 mtime, gint64 ctime,
DBusGMethodInvocation *context)
{
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* Cleanup old data */
if (session->priv->transfer_hint_fifo >= 0)
close (session->priv->transfer_hint_fifo);
reset_transfer_hints (session);
/* Set transfer hints */
if (*fifo != '\0') {
session->priv->transfer_hint_fifo = open (fifo, O_RDONLY | O_NONBLOCK);
if (session->priv->transfer_hint_fifo < 0) {
ods_error_err2gerror (errno, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
}
if (*remote_filename != '\0')
session->priv->transfer_hint_name = g_strdup (remote_filename);
if (*type != '\0')
session->priv->transfer_hint_type = g_strdup (type);
session->priv->transfer_hint_size = size;
session->priv->transfer_hint_mtime = mtime;
session->priv->transfer_hint_ctime = ctime;
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
return TRUE;
}
gboolean
ods_session_delete_remote_file (OdsSession *session,
const gchar *remote_filename,
DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (*remote_filename == '\0' || strchr (remote_filename, '/')) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid remote filename");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->dbus_context) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_put (session->priv->obex_context, NULL,
remote_filename, NULL, 0, -1, FALSE, -1);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
session->priv->dbus_context = NULL;
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
static gboolean
ods_session_remote_action (OdsSession *session,
const gchar *remote_source,
const gchar *remote_destination,
guint8 action, DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
OdsObexContext *obex_context = session->priv->obex_context;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_GOEP &&
session->priv->service != ODS_SERVICE_FTP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* validate remote_source */
if (strchr (remote_source, '/')) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid character in remote_source ('/')");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->dbus_context) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
/* do selected action */
ret = ods_obex_action (obex_context, remote_source,
remote_destination, action, 0);
if (ret < 0) {
ods_error_err2gerror(ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
/* reset state */
session->priv->dbus_context = NULL;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
gboolean
ods_session_remote_copy (OdsSession *session,
const gchar *remote_source,
const gchar *remote_destination,
DBusGMethodInvocation *context)
{
return ods_session_remote_action (session, remote_source,
remote_destination, OBEX_ACTION_COPY,
context);
}
gboolean
ods_session_remote_move (OdsSession *session,
const gchar *remote_source,
const gchar *remote_destination,
DBusGMethodInvocation *context)
{
return ods_session_remote_action (session, remote_source,
remote_destination, OBEX_ACTION_MOVE,
context);
}
static void
get_image_info_cb (OdsImageInfo *info, OdsSessionPutImageData *data)
{
GError *error = NULL;
gchar *basename;
gchar *pixel_str;
const gchar *transformation_str;
gint ret;
if (!info->encoding) {
/* Could not acquire image info */
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not acquire image info");
dbus_g_method_return_error (data->context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (data->session);
goto out;
}
if (data->only_get_info) {
dbus_g_method_return (data->context, info->width, info->height,
g_strdup (info->encoding));
ODS_SESSION_UNLOCK (data->session);
goto out;
}
basename = g_path_get_basename (info->filename);
pixel_str = ods_imaging_get_pixel_string (info->width, info->height);
transformation_str = ods_imaging_get_transformation_string (
info->transformation);
ret = ods_obex_put_image (data->session->priv->obex_context, info->filename,
basename, info->encoding, pixel_str,
info->size, transformation_str);
g_free (basename);
g_free (pixel_str);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (data->context, error);
g_clear_error (&error);
/* reset state */
data->session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (data->session);
goto out;
}
dbus_g_method_return (data->context);
ODS_SESSION_UNLOCK (data->session);
out:
g_free (data);
ods_image_info_free (info);
}
gboolean
ods_session_get_image_info (OdsSession *session, const gchar *local_path,
DBusGMethodInvocation *context)
{
GError *error = NULL;
OdsSessionPutImageData *cb_data;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!g_file_test (local_path, G_FILE_TEST_IS_REGULAR)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
cb_data = g_new0 (OdsSessionPutImageData, 1);
cb_data->session = session;
cb_data->context = context;
cb_data->only_get_info = TRUE;
if (!ods_imaging_get_image_info_async (local_path,
(OdsImagingFunc)get_image_info_cb, cb_data)) {
#ifdef USE_IMAGEMAGICK
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not create thread");
#else
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported (ImageMagick support disabled)");
#endif
dbus_g_method_return_error (context, error);
g_clear_error (&error);
g_free (cb_data);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
gboolean
ods_session_put_image (OdsSession *session,
const gchar *local_path,
DBusGMethodInvocation *context)
{
GError *error = NULL;
OdsSessionPutImageData *cb_data;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_BIP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->imaging_feature != BIP_SUPP_FEAT_IMAGE_PUSH &&
session->priv->imaging_feature != BIP_SUPP_FEAT_REMOTE_DISPLAY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected imaging feature");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!g_file_test (local_path, G_FILE_TEST_IS_REGULAR)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
session->priv->state = ODS_SESSION_STATE_BUSY;
cb_data = g_new0 (OdsSessionPutImageData, 1);
cb_data->session = session;
cb_data->context = context;
if (!ods_imaging_get_image_info_async (local_path,
(OdsImagingFunc)get_image_info_cb, cb_data)) {
#ifdef USE_IMAGEMAGICK
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not create thread");
#else
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported (ImageMagick support disabled)");
#endif
dbus_g_method_return_error (context, error);
g_clear_error (&error);
g_free (cb_data);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
static void
resize_image_cb (OdsImageInfo *info, OdsSessionPutImageData *data)
{
GError *error = NULL;
gchar *basename;
gchar *pixel_str;
const gchar *transformation_str;
gint ret;
session_message (data->session, "resize_image_cb");
if (!info->resized_image_filename) {
/* Could not acquire image info */
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not resize/encode image");
dbus_g_method_return_error (data->context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (data->session);
goto out;
}
basename = g_path_get_basename (info->filename);
pixel_str = ods_imaging_get_pixel_string (info->width, info->height);
transformation_str = ods_imaging_get_transformation_string (
info->transformation);
ret = ods_obex_put_image (data->session->priv->obex_context,
info->resized_image_filename,
basename, info->encoding, pixel_str,
info->size, transformation_str);
g_free (basename);
g_free (pixel_str);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (data->context, error);
g_clear_error (&error);
/* reset state */
data->session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (data->session);
goto out;
}
dbus_g_method_return (data->context);
ODS_SESSION_UNLOCK (data->session);
out:
g_free (data);
ods_image_info_free (info);
}
gboolean
ods_session_put_image_resized (OdsSession *session, const gchar *local_path,
guint16 width, guint16 height,
const gchar *encoding,
const gchar *transformation,
DBusGMethodInvocation *context)
{
GError *error = NULL;
OdsSessionPutImageData *cb_data;
const gchar *encoding_local;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_BIP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->imaging_feature != BIP_SUPP_FEAT_IMAGE_PUSH &&
session->priv->imaging_feature != BIP_SUPP_FEAT_REMOTE_DISPLAY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected imaging feature");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!g_file_test (local_path, G_FILE_TEST_IS_REGULAR)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
session->priv->state = ODS_SESSION_STATE_BUSY;
cb_data = g_new0 (OdsSessionPutImageData, 1);
cb_data->session = session;
cb_data->context = context;
if (*encoding == '\0')
encoding_local = NULL;
else
encoding_local = encoding;
if (!ods_imaging_resize_image_async (local_path, width, height,
encoding, ods_imaging_get_transformation (transformation),
(OdsImagingFunc)resize_image_cb, cb_data)) {
#ifdef USE_IMAGEMAGICK
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"Could not create thread");
#else
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported (ImageMagick support disabled)");
#endif
dbus_g_method_return_error (context, error);
g_clear_error (&error);
g_free (cb_data);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
return TRUE;
}
gboolean
ods_session_put_linked_attachment (OdsSession *session,
const gchar *image_handle,
const gchar *local_path,
const gchar *content_type,
const gchar *charset,
DBusGMethodInvocation *context)
{
GError *error = NULL;
const gchar *remote_used;
gchar *basename = NULL;
gint ret;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_BIP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->imaging_feature != BIP_SUPP_FEAT_IMAGE_PUSH) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected imaging feature");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!(session->priv->imaging_sdp_data->supp_functions &
BIP_SUPP_FUNC_PUT_LINKED_ATTACHMENT)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by remote device");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!g_file_test (local_path, G_FILE_TEST_IS_REGULAR)) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid local path");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (*image_handle == '\0') {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid image handle");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->transfer_hint_name)
remote_used = session->priv->transfer_hint_name;
else {
basename = g_path_get_basename (local_path);
remote_used = basename;
}
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_put_linked_attachment (session->priv->obex_context,
local_path, image_handle, remote_used,
content_type, charset, 0, -1);
g_free (basename);
reset_transfer_hints (session);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
return TRUE;
}
static gboolean
ods_session_remote_display_full (OdsSession *session,
const gchar *image_handle,
guint8 action,
DBusGMethodInvocation *context)
{
gint ret;
GError *error = NULL;
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->service != ODS_SERVICE_BIP) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected profile");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->imaging_feature != BIP_SUPP_FEAT_REMOTE_DISPLAY) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_NOT_SUPPORTED,
"Function not supported by selected imaging feature");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (!ods_session_check_state (session, context)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (action == BIP_REMOTEDISPLAY_SELECTIMAGE && *image_handle == '\0') {
g_set_error (&error, ODS_ERROR, ODS_ERROR_INVALID_ARGUMENTS,
"Invalid image handle");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (session->priv->dbus_context) {
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
session->priv->state = ODS_SESSION_STATE_BUSY;
ret = ods_obex_remote_display (session->priv->obex_context, image_handle,
action);
if (ret < 0) {
ods_error_err2gerror (ret, &error);
dbus_g_method_return_error (context, error);
g_clear_error (&error);
session->priv->dbus_context = NULL;
/* reset state */
session->priv->state = ODS_SESSION_STATE_OPEN;
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* will actually return when we get REQ_DONE */
return TRUE;
}
gboolean
ods_session_remote_display_select_image (OdsSession *session,
const gchar *image_handle,
DBusGMethodInvocation *context)
{
return ods_session_remote_display_full (session, image_handle,
BIP_REMOTEDISPLAY_SELECTIMAGE,
context);
}
gboolean
ods_session_remote_display_show_current_image (OdsSession *session,
DBusGMethodInvocation *context)
{
return ods_session_remote_display_full (session, "",
BIP_REMOTEDISPLAY_CURRENTIMAGE,
context);
}
gboolean
ods_session_remote_display_show_next_image (OdsSession *session,
DBusGMethodInvocation *context)
{
return ods_session_remote_display_full (session, "",
BIP_REMOTEDISPLAY_NEXTIMAGE,
context);
}
gboolean
ods_session_remote_display_show_previous_image (OdsSession *session,
DBusGMethodInvocation *context)
{
return ods_session_remote_display_full (session, "",
BIP_REMOTEDISPLAY_PREVIOUSIMAGE,
context);
}
GHashTable *
ods_session_get_transfer_info (OdsSession *session)
{
return ods_obex_transfer_get_info (session->priv->obex_context);
}
gboolean
ods_session_is_busy (OdsSession *session)
{
/* check for any operation (except transfers) */
if (!g_static_mutex_trylock (&session->priv->mutex))
return TRUE;
else
g_static_mutex_unlock (&session->priv->mutex);
/* check for transfers */
return (session->priv->state == ODS_SESSION_STATE_BUSY);
}
gboolean
ods_session_cancel_internal (OdsSession *session)
{
OdsObexContext *ctxt = session->priv->obex_context;
if (session->priv->state != ODS_SESSION_STATE_BUSY) {
/* emit CANCELLED signal now */
g_signal_emit (session, signals[CANCELLED], 0);
return FALSE;
}
if (ctxt->obex_cmd == OBEX_CMD_PUT) {
/* Send CMD_ABORT now */
OBEX_CancelRequest (ctxt->obex_handle, TRUE);
} else {
/* Send RSP_FORBIDDEN at obex_readstream;
* cleanup will be done in obex_event */
ctxt->cancelled = TRUE;
}
return TRUE;
}
gboolean
ods_session_cancel (OdsSession *session, DBusGMethodInvocation *context)
{
ODS_SESSION_LOCK (session);
/* do checks */
if (!ods_check_caller (context, session->priv->owner)) {
ODS_SESSION_UNLOCK (session);
return FALSE;
}
if (ods_session_cancel_internal (session)) {
if (session->priv->dbus_context) {
GError *error;
g_set_error (&error, ODS_ERROR, ODS_ERROR_FAILED,
"DBus context is set (this is probably a bug)");
dbus_g_method_return_error (context, error);
g_clear_error (&error);
ODS_SESSION_UNLOCK (session);
return FALSE;
}
/* set dbus context */
session->priv->dbus_context = context;
/* will return at obex_event{EV_ABORT} */
} else {
dbus_g_method_return (context);
ODS_SESSION_UNLOCK (session);
}
return TRUE;
}
obex-data-server-0.4.6/src/ods-error.h 0000644 0001750 0001750 00000004163 11524724173 014500 0000000 0000000 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*-
*
* Copyright (C) 2007-2008 Tadas Dailyda
*
* Licensed under the GNU General Public License Version 2
*
* 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#ifndef __ODS_ERROR_H
#define __ODS_ERROR_H
#include
G_BEGIN_DECLS
#define ODS_ERROR_DBUS_INTERFACE "org.openobex.Error"
#define ODS_ERROR (ods_error_quark ())
#define ODS_TYPE_ERROR (ods_error_get_type ())
typedef enum {
ODS_ERROR_INVALID_ARGUMENTS,
ODS_ERROR_CONNECTION_ATTEMPT_FAILED,
ODS_ERROR_NOT_SUPPORTED,
ODS_ERROR_NOT_FOUND,
ODS_ERROR_BUSY,
ODS_ERROR_NOT_AUTHORIZED,
ODS_ERROR_OUT_OF_MEMORY,
ODS_ERROR_FAILED,
ODS_ERROR_NOT_CONNECTED,
ODS_ERROR_FORBIDDEN,
ODS_ERROR_LINK_ERROR,
ODS_ERROR_BAD_DATA,
ODS_ERROR_STARTED,
ODS_ERROR_NOT_STARTED,
ODS_ERROR_TRANSPORT_NOT_AVAILABLE,
ODS_ERROR_CONNECTION_REFUSED,
ODS_ERROR_CONNECTION_TIMEOUT,
ODS_ERROR_BAD_REQUEST,
ODS_ERROR_NOT_IMPLEMENTED,
ODS_ERROR_SERVER_ERROR,
ODS_ERROR_TIMEOUT,
ODS_ERROR_CANCELLED,
ODS_ERROR_NOT_MODIFIED,
ODS_ERROR_DATABASE_ERROR,
ODS_ERROR_CONFLICT,
ODS_ERROR_UNSUPPORTED_MEDIA_TYPE,
ODS_ERROR_NO_FIFO_READER
} OdsError;
GQuark ods_error_quark (void);
GType ods_error_get_type (void);
void ods_error_err2gerror (int err, GError **error);
void ods_error_obexrsp2gerror (gint obex_response, GError **error);
gchar *ods_error_get_dbus_name (GError *error);
G_END_DECLS
#endif /* __ODS_ERROR_H */
obex-data-server-0.4.6/ChangeLog 0000644 0001750 0001750 00000161516 11546317424 013405 0000000 0000000 ====== obex-data-server-0.4.6 ======
2011-02-10 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_get):
Fix server GET when type is not set (fixes #493, #584)
2010-10-28 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_setpath):
* src/ods-obex.h:
* src/ods-server-session.c (obex_event):
Disable directory creation when writing is not allowed (path by nami; #492)
2010-10-27 Tadas Dailyda
* src/ods-server-session.c (send_image_handle):
Fix BIP image PUT in server-side (patch by nami; #490)
2010-02-06 Tadas Dailyda
* src/ods-logging.c (ods_log_obex):
* src/ods-logging.h:
* src/ods-server-session.c (obex_event):
* src/ods-session.c (session_log), (obex_io_callback),
(obex_request_done), (obex_event), (ods_session_finalize),
(resize_image_cb):
Improve message logging for sessions so that message is always prefixed
with session's dbus path
2010-01-22 Tadas Dailyda
* src/ods-bluez.c (sdp_initiate_search), (ods_bluez_cancel_get_client_socket):
Fix crasher during SDP discovery
2010-01-03 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_get), (ods_obex_srv_put):
Handle invalid Type header gracefully
2009-10-22 Tadas Dailyda
* configure.ac:
* src/ods-usb.c:
* src/ods-usb.h:
Fix ods-usb.{c|h} to not include usb.h when using --disable-usb (#215)
====== obex-data-server-0.4.5 ======
2009-10-18 Tadas Dailyda
* dbus-api.txt:
Add info about suspend timeouts
2009-10-18 Tadas Dailyda
* test/ods-opp-test.py:
* test/ods-server-test.py:
update test scripts to support tty transport
2009-10-18 Tadas Dailyda
* src/ods-logging.c (log_handler):
* src/ods-manager.c (tty_open):
* test/ods-server-test.py:
Little fix in logging, enable tty transport in ods-server-test.py
2009-10-18 Tadas Dailyda
* data/obex-data-server.1:
* src/ods-main.c (main):
* src/ods-obex.c (ods_obex_susp_timeout),
(ods_obex_transfer_suspend):
* src/ods-obex.h:
Update man page, implement suspend timeouts, fix -v
2009-09-02 Tadas Dailyda
* Makefile.am:
* acinclude.m4:
* autogen.sh:
* configure.ac:
* configure.in:
* data/Makefile.am:
* dbus-api.txt:
* src/Makefile.am:
* src/ods-capabilities.c (ods_get_capability),
(ods_get_imaging_capabilities):
* src/ods-manager.c (ods_manager_session_list_add),
(ods_manager_session_info_free), (client_socket_connected_cb),
(tty_open), (create_bluetooth_session_full),
(ods_manager_create_usb_session), (connect_tty_session),
(ods_manager_create_tty_session), (ods_manager_create_tty_server),
(ods_manager_get_session_info):
* src/ods-manager.h:
* src/ods-manager.xml:
* src/ods-obex.c (ods_obex_get_new_path):
* src/ods-server-session.c (ods_server_session_finalize):
* src/ods-server.c (server_session_disconnected_cb),
(connect_callback), (ods_server_attach_callback),
(ods_server_constructor), (ods_server_finalize):
* src/ods-session.c:
* test/Makefile.am:
Use non-recursive/silent build system, add support for TTY sessions,
fix TTY server support, other bug fixes and code cleanup
2009-08-25 Tadas Dailyda
* configure.in:
* dbus-api.txt:
* src/ods-logging.c (log_handler):
* src/ods-manager.c (ods_manager_server_list_add),
(ods_manager_server_info_free), (server_started_cb),
(server_stopped_cb), (ods_manager_create_bluetooth_server),
(tty_init), (ods_manager_create_tty_server),
(ods_manager_get_server_info):
* src/ods-manager.h:
* src/ods-manager.xml:
* src/ods-obex.c (ods_obex_get_new_path), (ods_obex_context_new),
(ods_obex_setup_fdtransport), (ods_obex_connect_done),
(ods_obex_srv_connect):
* src/ods-obex.h:
* src/ods-server-session.c (ods_server_session_set_property),
(ods_server_session_get_property), (ods_server_session_class_init):
* src/ods-server-session.h:
* src/ods-server.c (ods_server_session_list_add),
(connect_callback), (ods_server_set_property),
(ods_server_get_property), (ods_server_class_init),
(ods_server_init), (ods_server_finalize),
(ods_server_get_server_session_info):
* src/ods-server.h:
* src/ods-session.c (ods_session_set_property):
Add TTY server support, fix debug off in logging, refine filename choosing,
prepare for 0.4.5 release
2009-08-23 Tadas Dailyda
* src/ods-obex.c (ods_obex_timeout), (ods_obex_setup_fdtransport),
(ods_obex_close_transport), (ods_obex_writestream):
* src/ods-obex.h:
* src/ods-server-session.c (emit_disconnected),
(ods_server_session_set_property),
(ods_server_session_cancel_internal):
* src/ods-session.c (emit_connect_result_internal),
(emit_disconnected), (ods_session_set_property),
(ods_session_cancel_internal):
Fix one newly introduced bug, workaround request cancelling bug in openobex
2009-08-22 Tadas Dailyda
* src/ods-common.c (ods_safe_gsource_remove):
* src/ods-common.h:
* src/ods-logging.c:
* src/ods-obex.c (ods_obex_timeout), (ods_obex_io):
* src/ods-session.c (emit_connect_result_internal),
(emit_disconnected):
Add ods_safe_gsource_remove for safely removing event sources
2009-08-22 Tadas Dailyda
* src/ods-manager.c (ods_manager_get_usb_interface_info):
* src/ods-obex.c (ods_process_usb_input), (ods_obex_timeout),
(ods_obex_send), (ods_obex_io), (ods_obex_setup_fdtransport),
(ods_obex_setup_usbtransport), (ods_obex_connect_done),
(ods_obex_connect), (ods_obex_srv_connect), (ods_obex_disconnect),
(ods_obex_readstream), (ods_obex_get), (ods_obex_put_full),
(ods_obex_setpath), (ods_obex_action):
* src/ods-obex.h:
* src/ods-session.c (emit_connect_result_internal),
(emit_disconnected), (obex_usbevent), (ods_session_set_property):
* src/ods-session.h:
* src/ods-usb.c (find_obex_data_interface),
(find_obex_service_descriptor):
Implement timeout system, various code cleanup all over the place
2009-08-22 Tadas Dailyda
* src/ods-obex.c (ods_obex_setup_fdtransport),
(ods_obex_setup_usbtransport):
* src/ods-obex.h:
* src/ods-server-session.c (ods_server_session_set_property):
* src/ods-session.c (ods_session_set_property):
* test/Makefile.am:
Move transport setup to ods-obex.c, add obex_event to OdsObexContext,
distribute ods-opp-test.py
2009-08-20 Tadas Dailyda
* autogen.sh:
* configure.in:
* test/ods-opp-test.py:
Add silent rules to automake, add simple OPP send test script
2009-08-17 Tadas Dailyda
* data/obex-data-server.1:
* src/Makefile.am:
* src/ods-logging.c (log_handler), (ods_log_init),
(ods_log_finalize), (ods_log_obex):
* src/ods-logging.h:
* src/ods-main.c (ods_service_register), (main):
* src/ods-server-session.c (obex_event):
* src/ods-session.c (obex_event):
Add more advanced logging functionality with ability to log to syslog
2009-07-16 Tadas Dailyda
* src/ods-main.c (main):
Use locales ONLY for filenames!
2009-06-02 Tadas Dailyda
* data/obex-data-server.conf:
* test/ods-dbus-test.c (session_connected_cb),
(session_connect_error_cb):
Fix system bus configuration, update ods-dbus-test.c a little bit
2009-04-17 Tadas Dailyda
* dbus-api.txt:
Fix RetrieveFolderListing description
2009-02-14 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_get):
Add support for GET using folder listing type
and name header in server
2009-02-10 Tadas Dailyda
* src/ods-bluez.c (client_socket_connect_cb), (rfcomm_connect),
(sdp_get_channel), (sdp_search_completed_cb),
(sdp_search_process_cb), (sdp_connect_watch),
(ods_bluez_cancel_get_client_socket):
* src/ods-bluez.h:
* src/ods-manager.c (client_socket_connected_cb),
(create_bluetooth_session_full):
* src/ods-session.c (ods_session_class_init):
* test/ods-session-test.py:
Revert previous changes and update ods-session-test.py
to actually work with 0.4 API
2009-02-10 Tadas Dailyda
* src/ods-bluez.c (client_socket_connect_cb), (rfcomm_connect),
(sdp_get_channel), (sdp_search_completed_cb),
(sdp_search_process_cb), (sdp_connect_watch),
(ods_bluez_cancel_get_client_socket):
* src/ods-bluez.h:
* src/ods-manager.c (client_socket_connected_cb),
(create_bluetooth_session_full):
* src/ods-session.c (ods_session_class_init):
Use NOKIAFTP_UUID for CMD_CONNECT if discovered via SDP
====== obex-data-server-0.4.4 ======
2009-02-09 Tadas Dailyda
* configure.in:
* src/ods-usb.c (find_obex_service_descriptor):
* src/ods-usb.h:
Don't depend on openobex 1.4 for USB interface discovery
====== obex-data-server-0.4.3 ======
2009-02-08 Tadas Dailyda
* configure.in:
* dbus-api.txt:
Clarify how non-transfer methods work in documentation
2009-02-08 Tadas Dailyda
* configure.in:
Require only openobex 1.3 if usb support is disabled
2009-02-08 Tadas Dailyda
* configure.in:
Bump openobex dependency to 1.4 (needed for new USB stuff)
2009-02-06 Tadas Dailyda
* dbus-api.txt:
* src/ods-obex.c (ods_obex_transfer_get_info):
Add OBEXCommand to transfer info for distinguishing between
PUT and GET requests
2009-02-06 Tadas Dailyda
* src/ods-bluez.c (ods_bluez_cancellable_free),
(sdp_search_completed_cb), (sdp_initiate_search),
(sdp_connect_watch), (ods_bluez_get_client_socket):
* src/ods-bluez.h:
* src/ods-obex.c (ods_obex_writestream):
Fix Nokia UUID workaround (this was apparently broken in 0.4)
2009-01-31 Tadas Dailyda
* configure.in:
* src/Makefile.am:
* src/ods-manager.c (ods_manager_get_usb_interfaces_num),
(ods_manager_get_usb_interface_info):
* src/ods-session.c (ods_session_set_transfer_hints):
* src/ods-usb.c (find_eps), (find_obex_data_interface),
(get_intf_string), (check_intf), (find_obex_service_descriptor),
(ods_usbobex_find_interfaces), (ods_usbobex_free_interface),
(ods_usbobex_free_interfaces):
* src/ods-usb.h:
* test/ods-dbus-test.c (session_connected_cb):
* test/ods-session-test.py:
Make USB interface discovery independent from openobex to be able to
export more information (thanks to Bastien Nocera), check for errors
in Session.SetTransferHints
2009-01-27 Tadas Dailyda
* src/ods-server-session.c:
* src/ods-session.c (ods_session_set_transfer_hints):
* src/ods-session.h:
* src/ods-session.xml:
Export RemoteCopy and RemoteMove methods through DBus,
add function names to LOCK/UNLOCK debug messages
2009-01-24 Tadas Dailyda
* src/ods-obex.c (ods_obex_put_full), (ods_obex_put),
(ods_obex_put_image), (ods_obex_put_linked_thumbnail),
(ods_obex_put_linked_attachment), (ods_obex_remote_display):
* src/ods-obex.h:
* src/ods-session.c (reset_transfer_hints), (ods_session_init),
(ods_session_copy_remote_file_full), (ods_session_send_file_ext),
(ods_session_set_transfer_hints), (ods_session_delete_remote_file):
* src/ods-session.h:
* src/ods-session.xml:
Further work on FIFO support, fix up Session.SetTransferHints
2009-01-16 Tadas Dailyda
* src/ods-session.c (ods_session_copy_remote_file_full):
Fix Session.CopyRemoteFile.. to allow empty local_path
2008-11-30 Tadas Dailyda
* src/ods-error.c (ods_error_get_type), (ods_error_err2gerror):
* src/ods-error.h:
* src/ods-manager.c (ods_manager_create_bluetooth_server):
* src/ods-obex.c (get_target_size_and_time),
(ods_obex_transfer_close), (ods_obex_disconnect), (fifo_watch),
(ods_obex_readstream), (ods_obex_writestream), (ods_obex_get),
(ods_obex_srv_get), (ods_obex_put_full), (ods_obex_srv_setpath),
(ods_obex_put_image), (ods_obex_put_linked_thumbnail),
(ods_obex_put_linked_attachment):
* src/ods-obex.h:
* src/ods-server-session.c (obex_suspend_request),
(obex_request_put), (ods_server_session_accept),
(ods_server_session_reject), (ods_server_session_cancel_internal):
* src/ods-session.c (local_file_test), (reset_transfer_hints),
(ods_session_init), (ods_session_finalize),
(ods_session_copy_remote_file_full), (ods_session_get_by_type),
(ods_session_send_file_ext), (ods_session_set_transfer_hints),
(ods_session_delete_remote_file),
(ods_session_put_linked_attachment):
* src/ods-session.h:
* src/ods-session.xml:
Add support for using FIFOs instead of regular files for transfers,
add Session.SetTransferHints for specifying different name, size and
modification time when sending from FIFO
2008-11-27 Tadas Dailyda
* src/ods-bluez.c (rfcomm_connect), (ods_bluez_get_client_socket),
(ods_bluez_cancel_get_client_socket):
* src/ods-bluez.h:
Properly close RFCOMM socket in Manager.CancelSessionConnect
2008-11-27 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_put):
* src/ods-obex.h:
* src/ods-server-session.c (obex_request_put):
Fix emmision of ServerSession.TransferCompleted signal when suspending
small file transfer
2008-11-25 Tadas Dailyda
* src/ods-server-session.c (obex_request_cancelled),
(obex_suspend_request), (obex_request_put), (obex_event):
Fix request suspending for very small files
2008-11-25 Tadas Dailyda
* src/ods-obex.c (ods_obex_transfer_new):
Reset obex_context->Cancelled for subsequent transfers
2008-11-24 Tadas Dailyda
* src/ods-server-session.c (ods_server_session_cancel):
Properly return from ServerSession.Cancel when no operation in progress
2008-11-24 Tadas Dailyda
* src/ods-session.c (ods_session_cancel):
Properly return from Session.Cancel when no operation in progress
2008-11-24 Tadas Dailyda
* dbus-api.txt:
Fix ErrorOccurred in docs (double 'r')
2008-11-24 Tadas Dailyda
* src/ods-error.c (ods_error_get_type), (ods_error_obexrsp2gerror):
* src/ods-error.h:
Add UnsupportedMediaType error and fix another typo
2008-11-24 Tadas Dailyda
* src/ods-error.c (ods_error_err2gerror):
Fix a typo in error conversion code
2008-11-15 Tadas Dailyda
* src/ods-obex.c (ods_obex_srv_put):
Fix a nasty crash when type header is not received
2008-11-14 Tadas Dailyda