[jachu19]

Hi, my job is to send something from a mobile to PC or to other side using BT. My code is still growing up for new samples from the forum, but i still havent sent a file. Can someone give me a simple file transfer example, please...
last thing a did was an opening a OBEXObjectPushServiceClass_UUID but it stops on accecp() and phone doesn't see my computer to send a file.
I tried two ways of connecting, XP SP1 Api and WSA.
below my code (in parts), but not necessary i suppose:


#include <winsock2.h>
#include <Ws2bth.h>
#include <BluetoothAPIs.h>
#include <string.h>
#include <conio.h>

#include <stdio.h>
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "irprops.lib")

#define MAX_DEVICES 20
#define MAX_STRING_LENGHT 100
#define MAX_RADIOS 5
#define MAX_MAC_ADDR_LENGHT 6

int temp();

TCHAR *GetLastErrorMessage(DWORD last_error)
{
static TCHAR errmsg[512];

if (!FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
0,
last_error,
0,
errmsg,
511,
NULL))
{
/* if we fail, call ourself to find out why and return that error */
return (GetLastErrorMessage(GetLastError()));
}

return errmsg;
}

BOOL __stdcall enum_callback(
ULONG uAttribId,
LPBYTE pValueStream,
ULONG cbStreamSize,
LPVOID pvParam)
{
//printf("enum_callback %d\n", uAttribId);
SDP_ELEMENT_DATA element;
if (ERROR_SUCCESS != BluetoothSdpGetElementData(pValueStream, cbStreamSize, &element))
{
printf("%s", GetLastErrorMessage(GetLastError()));
}
return true;
}

BOOL __cdecl auth_callback(LPVOID pvParam, PBLUETOOTH_DEVICE_INFO pDevice)
{
//printf("auth_callback\n");
int j, result;
HANDLE hRadio = (HANDLE)pvParam;
WCHAR tempkey[12] = {0};
PWCHAR pszPasskey = tempkey;
for (j = 0; j < 8; j+=2)
{
((unsigned char*)pszPasskey)[j] = '0';
}
for (j = 1; j < 8; j+=2)
{
((unsigned char*)pszPasskey)[j] = 0x0;
}
wprintf(L"pszPasskey sent in callback: %20s\n", pszPasskey);
result = BluetoothSendAuthenticationResponse(hRadio, pDevice, pszPasskey);
if (result != ERROR_SUCCESS)
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
return true;
}

BOOL __stdcall dev_callback(LPVOID pvParam, PBLUETOOTH_DEVICE_INFO pDevice)
{
//printf("dev_callback\n");
return true;
}


int BT_open_socket(SOCKET *s, WSAPROTOCOL_INFO* protocolInfo, int* protocolInfoSize)
{
*s = socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
if (*s == INVALID_SOCKET)
{
printf("Failed to get bluetooth socket! %s\n", GetLastErrorMessage(GetLastError()));
return 1;
}
if (0 != getsockopt(*s, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)protocolInfo, protocolInfoSize))
{
printf("Failed to get bluetooth opt! %s\n", GetLastErrorMessage(GetLastError()));
return 1;
}
return 0;
}

int BT_find_all_devices(char addressAsString_table[MAX_DEVICES][MAX_STRING_LENGHT],
char nameAsString_table[MAX_DEVICES][MAX_STRING_LENGHT],
WSAPROTOCOL_INFO* protocolInfo)
{
WSAQUERYSET querySet;
memset(&querySet, 0, sizeof(querySet));
querySet.dwSize = sizeof(querySet);
querySet.dwNameSpace = NS_BTH;
HANDLE hLookup;
DWORD flags = LUP_RETURN_NAME | LUP_CONTAINERS |
LUP_RETURN_ADDR | LUP_FLUSHCACHE |
LUP_RETURN_TYPE | LUP_RETURN_BLOB |
LUP_RES_SERVICE;
int result, i;

//buffer for returned results
BYTE buffer[1000];
DWORD bufferLength = sizeof(buffer);
WSAQUERYSET *pResults = (WSAQUERYSET*)&buffer;
CSADDR_INFO *pCSAddr;

//buffer for MAC address
char addressAsString[MAX_STRING_LENGHT];
DWORD addressSize = sizeof(addressAsString);

result = WSALookupServiceBegin(&querySet, flags, &hLookup);
if (0 == result)
{
i = 0;
while (0 == result)
{
if (i >= MAX_DEVICES)
{
printf("Cannot assign next device, MAX_DEVICES = %d reached\n", MAX_DEVICES);
return MAX_DEVICES;
}

result = WSALookupServiceNext(hLookup, flags, &bufferLength, pResults);
if (result != 0)
{
//printf("%s\n", GetLastErrorMessage(GetLastError()));
return i;
}
else
{
pCSAddr = (CSADDR_INFO *)pResults->lpcsaBuffer;
addressSize = sizeof(addressAsString);
if (0 == WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength, protocolInfo, addressAsString, &addressSize))
{
//printf("device address[%d]: %s\n", i, addressAsString);
strcpy(addressAsString_table[i], addressAsString);
strcpy(nameAsString_table[i], pResults->lpszServiceInstanceName);
i++;
}
}
}
result = WSALookupServiceEnd(hLookup);
if (result != 0)
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}

return i;
}

int BT_find_devices_by_context(char addressAsString_table[MAX_DEVICES][MAX_STRING_LENGHT],
char nameAsString_table[MAX_DEVICES][MAX_STRING_LENGHT],
WSAPROTOCOL_INFO* protocolInfo,
char * context)
{
WSAQUERYSET querySet;
memset(&querySet, 0, sizeof(querySet));
querySet.dwSize = sizeof(querySet);
querySet.dwNameSpace = NS_BTH;
GUID protocol = L2CAP_PROTOCOL_UUID;
querySet.lpServiceClassId = &protocol;
querySet.lpszContext = context;
HANDLE hLookup;
DWORD flags = LUP_RETURN_NAME | LUP_FLUSHCACHE |
LUP_RETURN_TYPE | LUP_RETURN_ADDR |
LUP_RETURN_BLOB | LUP_RETURN_COMMENT;
int result, i;

//buffer for returned results
BYTE buffer[2000];
DWORD bufferLength = sizeof(buffer);
WSAQUERYSET *pResults = (WSAQUERYSET*)&buffer;
CSADDR_INFO *pCSAddr;

//buffer for MAC address
char addressAsString[MAX_STRING_LENGHT];
DWORD addressSize = sizeof(addressAsString);

result = WSALookupServiceBegin(&querySet, flags, &hLookup);
if (0 == result)
{
i = 0;
while (0 == result)
{
if (i >= MAX_DEVICES)
{
printf("Cannot assign next device, MAX_DEVICES = %d reached\n", MAX_DEVICES);
return MAX_DEVICES;
}

result = WSALookupServiceNext(hLookup, flags, &bufferLength, pResults);
if (result != 0)
{
return i;
}
else
{
pCSAddr = (CSADDR_INFO *)pResults->lpcsaBuffer;
addressSize = sizeof(addressAsString);
if (0 == WSAAddressToString(pCSAddr->RemoteAddr.lpSockaddr, pCSAddr->RemoteAddr.iSockaddrLength, protocolInfo, addressAsString, &addressSize))
{
//printf("device address[%d]: %s\n", i, addressAsString);
//printf("device name[%d]: %s\n", i, pResults->lpszServiceInstanceName);
strcpy(addressAsString_table[i], addressAsString);
strcpy(nameAsString_table[i], pResults->lpszServiceInstanceName);
i++;
}

if (pResults->lpBlob)
{
const BLOB *pBlob = (BLOB*)pResults->lpBlob;
if (!BluetoothSdpEnumAttributes(pBlob->pBlobData, pBlob->cbSize, enum_callback, 0))
{
printf("BluetoothSdpEnumAttributes - %s\n", GetLastErrorMessage(GetLastError()));
}
}

}
}
result = WSALookupServiceEnd(hLookup);
if (result != 0)
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
return i;
}

[jachu19]

int BT_radio_find_radios(HANDLE hRadio[MAX_RADIOS])
{
int i = 0;
HBLUETOOTH_RADIO_FIND hFind;
BLUETOOTH_FIND_RADIO_PARAMS btfrp = { sizeof(btfrp) };

hFind = BluetoothFindFirstRadio( &btfrp, &(hRadio[i]) );
if ( NULL != hFind )
{
//printf("found first radio\n");
i++;
while(TRUE == BluetoothFindNextRadio(hFind, &hRadio[i]))
{
i++;
if (i >= MAX_RADIOS)
{
printf("Cannot assign next radio, MAX_RADIOS = %d reached\n", MAX_RADIOS);
return MAX_RADIOS;
}
}
if (FALSE == BluetoothFindRadioClose(hFind))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
return i;
}

int BT_radio_find_devices(unsigned char address_table[MAX_DEVICES][MAX_MAC_ADDR_LENGHT],
char nameAsString_table[MAX_DEVICES][MAX_STRING_LENGHT],
HANDLE* hRadio)
{
BLUETOOTH_DEVICE_INFO deviceInfo;
deviceInfo.dwSize = sizeof(deviceInfo);
HBLUETOOTH_DEVICE_FIND hDeviceFind;

BLUETOOTH_DEVICE_SEARCH_PARAMS deviceSearchParams;
memset(&deviceSearchParams, 0, sizeof(deviceSearchParams));
deviceSearchParams.dwSize = sizeof(deviceSearchParams);
deviceSearchParams.fReturnAuthenticated = true;
deviceSearchParams.fReturnRemembered = true;
deviceSearchParams.fReturnUnknown = true;
deviceSearchParams.fReturnConnected = true;
deviceSearchParams.fIssueInquiry = true;
deviceSearchParams.cTimeoutMultiplier = 10;
deviceSearchParams.hRadio = *hRadio;
int i = 0;

hDeviceFind = BluetoothFindFirstDevice(&deviceSearchParams, &deviceInfo);
if (NULL != hDeviceFind)
{
do
{
memcpy(address_table[i], &deviceInfo.Address.rgBytes[0], MAX_MAC_ADDR_LENGHT);
memcpy(&nameAsString_table[i], &deviceInfo.szName, MAX_STRING_LENGHT);
//wprintf(L"Device: %s\n", deviceInfo.szName);
//BluetoothDisplayDeviceProperties(0, &deviceInfo);
i++;
if (i >= MAX_DEVICES)
{
printf("Cannot assign next device, MAX_DEVICES = %d reached\n", MAX_DEVICES);
return MAX_DEVICES;
}
}
while(BluetoothFindNextDevice(hDeviceFind, &deviceInfo));

if (FALSE == BluetoothFindDeviceClose(hDeviceFind))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
return i;
}

[jachu19]

void Connect_using_BT_Api()
{
int i, j, result;
HANDLE hRadio[MAX_RADIOS];
int found_radio_cnt = 0;
int selected_radio;
int found_radio_dev_cnt = 0;
int selected_radio_dev;

BLUETOOTH_RADIO_INFO radioInfo;
radioInfo.dwSize = sizeof(radioInfo);
BLUETOOTH_DEVICE_INFO deviceInfo;
memset(&deviceInfo, 0, sizeof(deviceInfo));
deviceInfo.dwSize = sizeof(deviceInfo);

unsigned char radio_dev_address[MAX_DEVICES][MAX_MAC_ADDR_LENGHT];
char radio_dev_names [MAX_DEVICES][MAX_STRING_LENGHT];

found_radio_cnt = BT_radio_find_radios(hRadio);
if (found_radio_cnt == 0)
{
printf("no radios found\n");
exit(1);
}
for (i = 0; i < found_radio_cnt; i++)
{
if (ERROR_SUCCESS == BluetoothGetRadioInfo(hRadio[0], &radioInfo))
{
wprintf(L"Radio[%2d]: %10s\n", i, radioInfo.szName);
}
}
printf("Select radio: ");
scanf("%d", &selected_radio);
if (selected_radio < 0) selected_radio = 0;
if (selected_radio >= found_radio_cnt) selected_radio = found_radio_cnt - 1;

if (ERROR_SUCCESS == BluetoothGetRadioInfo(hRadio[selected_radio], &radioInfo))
{
wprintf(L"selected: %10s\n", radioInfo.szName);
}

if (FALSE == BluetoothEnableDiscovery(hRadio[selected_radio], TRUE))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
if (FALSE == BluetoothEnableIncomingConnections(hRadio[selected_radio], TRUE))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}

found_radio_dev_cnt = BT_radio_find_devices(radio_dev_address, radio_dev_names, &hRadio[selected_radio]);
if (found_radio_dev_cnt == 0)
{
printf("no radio devices found\n");
exit(1);
}

for (i = 0; i < found_radio_dev_cnt; i++)
{
wprintf(L"Radio device[%2d]: %20s ", i, radio_dev_names[i]);
printf("addr: (%2x:%2x:%2x:%2x:%2x:%2x)\n",
radio_dev_address[i][5],
radio_dev_address[i][4],
radio_dev_address[i][3],
radio_dev_address[i][2],
radio_dev_address[i][1],
radio_dev_address[i][0]);
}

printf("Select device: ");
scanf("%d", &selected_radio_dev);
if (selected_radio_dev < 0) selected_radio_dev = 0;
if (selected_radio_dev >= found_radio_dev_cnt) selected_radio_dev = found_radio_dev_cnt - 1;

#if 0 //function works, but not needed
BLUETOOTH_SELECT_DEVICE_PARAMS seldevquery;
memset(&seldevquery, 0, sizeof(seldevquery));
seldevquery.dwSize = sizeof(seldevquery);
seldevquery.cNumOfClasses = 5;
seldevquery.hwndParent = 0;
seldevquery.fForceAuthentication = true;
seldevquery.fShowAuthenticated = true;
seldevquery.fShowRemembered = true;
seldevquery.fShowUnknown = true;
seldevquery.fAddNewDeviceWizard = false;
seldevquery.fSkipServicesPage = false;
seldevquery.pfnDeviceCallback = dev_callback;
seldevquery.pvParam = 0;
seldevquery.cNumDevices = 2;
seldevquery.pDevices = &deviceInfo;

if (FALSE == BluetoothSelectDevices(&seldevquery))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("poszlo: BluetoothSelectDevices\n");
wprintf(L"Selected device: %20s ", deviceInfo.szName);
printf("addr: (%2x:%2x:%2x:%2x:%2x:%2x)\n",
deviceInfo.Address.rgBytes[5],
deviceInfo.Address.rgBytes[4],
deviceInfo.Address.rgBytes[3],
deviceInfo.Address.rgBytes[2],
deviceInfo.Address.rgBytes[1],
deviceInfo.Address.rgBytes[0]);
}
#endif

#if 1
memcpy(&deviceInfo.Address.rgBytes[0], radio_dev_address[selected_radio_dev], MAX_MAC_ADDR_LENGHT);
if (ERROR_SUCCESS == BluetoothGetDeviceInfo(hRadio[selected_radio], &deviceInfo))
{
wprintf(L"Selected device: %20s ", deviceInfo.szName);
printf("addr: (%2x:%2x:%2x:%2x:%2x:%2x)\n",
deviceInfo.Address.rgBytes[5],
deviceInfo.Address.rgBytes[4],
deviceInfo.Address.rgBytes[3],
deviceInfo.Address.rgBytes[2],
deviceInfo.Address.rgBytes[1],
deviceInfo.Address.rgBytes[0]);

// BluetoothUpdateDeviceRecord(&deviceInfo);
// BluetoothRemoveDevice(deviceInfo.Address);
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
#endif

//GUID pService = {0x00001101, 0x0000, 0x1000, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB};
GUID pService = (GUID)SerialPortServiceClass_UUID;
//GUID pService = (GUID)OBEXFileTransferServiceClass_UUID;
//GUID pService = (GUID)OBEXObjectPushServiceClass_UUID;

if (ERROR_SUCCESS != BluetoothSetServiceState(hRadio[selected_radio], &deviceInfo, &pService, BLUETOOTH_SERVICE_ENABLE))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("BluetoothSetServiceState enabled (COM)\n");
}

#if 1
GUID guidServices[MAX_DEVICES];
memset(guidServices, 0, sizeof(guidServices));
DWORD numServices = MAX_DEVICES;
memcpy(&deviceInfo.Address.rgBytes[0], radio_dev_address[selected_radio_dev], MAX_MAC_ADDR_LENGHT);

if (ERROR_SUCCESS == BluetoothEnumerateInstalledServices(hRadio[selected_radio],
&deviceInfo,
&numServices,
guidServices))
{
printf("enumerated services: %d\n", numServices);
}
else
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
#endif

#if 1
if (ERROR_SUCCESS != BluetoothSetServiceState(hRadio[selected_radio], &deviceInfo, &pService, BLUETOOTH_SERVICE_DISABLE))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("BluetoothSetServiceState disabled (COM)\n");
}
#endif

//function works
HBLUETOOTH_AUTHENTICATION_REGISTRATION phRegHandle;
if (ERROR_SUCCESS != BluetoothRegisterForAuthentication(&deviceInfo,
&phRegHandle,
auth_callback,
hRadio[selected_radio]))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}

WCHAR tempkey[12] = {0};
PWCHAR pszPasskey = tempkey;
for (j = 0; j < 8; j+=2)
{
((unsigned char*)pszPasskey)[j] = '0';
}
for (j = 1; j < 8; j+=2)
{
((unsigned char*)pszPasskey)[j] = 0x0;
}
ULONG ulPasskeyLength = 4;
wprintf(L"pszPasskey: %20s\n", pszPasskey);

//works!!!!
result = BluetoothAuthenticateDevice(0, hRadio[selected_radio], &deviceInfo, pszPasskey, ulPasskeyLength);
if (result == ERROR_NO_MORE_ITEMS)
{
printf("%s\n", "device already authenticated");
}
else if(result != ERROR_SUCCESS)
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
CloseHandle( hRadio[selected_radio] );
}

void Connect_using_SWA()
{
int i;
//--- to open a socket -----
SOCKET s;
WORD wVersionRequested = 0x202;
WSADATA m_data;

WSAPROTOCOL_INFO protocolInfo;
int protocolInfoSize = sizeof(protocolInfo);

char known_addresses[MAX_DEVICES][MAX_STRING_LENGHT];
char known_names [MAX_DEVICES][MAX_STRING_LENGHT];
char selected_addresses [MAX_DEVICES][MAX_STRING_LENGHT];
char selected_names [MAX_DEVICES][MAX_STRING_LENGHT];

//BTH_DEVICE_INFO *pDeviceInfo;

int found_dev_cnt = 0;;
int selected_dev;
int found_serv_cnt = 0;
int selected_serv;

if (0 == WSAStartup(wVersionRequested, &m_data))
{
if (0 != BT_open_socket(&s, &protocolInfo, &protocolInfoSize))
{
exit(1);
}

found_dev_cnt = BT_find_all_devices(known_addresses, known_names, &protocolInfo);
if (found_dev_cnt == 0)
{
printf("no devices found\n");
exit(1);
}

for (i = 0; i < found_dev_cnt; i++)
{
printf("[%2d]: %20s ", i, known_names[i]);
printf("addr: %s\n", known_addresses[i]);
}
printf("Select device: ");
scanf("%d", &selected_dev);
if (selected_dev < 0) selected_dev = 0;
if (selected_dev >= found_dev_cnt) selected_dev = found_dev_cnt - 1;

found_serv_cnt = BT_find_devices_by_context(selected_addresses, selected_names, &protocolInfo, known_addresses[selected_dev]);
if (found_serv_cnt == 0)
{
printf("no services found\n");
exit(1);
}

for (i = 0; i < found_serv_cnt; i++)
{
printf("[%2d]: %20s ", i, selected_names[i]);
printf("addr: %s\n", selected_addresses[i]);
}
printf("Select service: ");
scanf("%d", &selected_serv);
if (selected_serv < 0) selected_serv = 0;
if (selected_serv >= found_serv_cnt) selected_serv = found_serv_cnt - 1;

printf("selected: %s\n", selected_names[selected_serv]);


WSACleanup();
}
}

[jachu19]

int temp()
{
WORD wVersionRequested = 0x202;
WSADATA m_data;

if (0 == ::WSAStartup(wVersionRequested, &m_data))
{
SOCKET s = ::socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);

const DWORD lastError = ::GetLastError();

if (s == INVALID_SOCKET)
{
printf("Failed to get bluetooth socket! %s\n", GetLastErrorMessage(lastError));
exit(1);
}
else
{
printf("Succes to get bluetooth socket.\n");
}

WSAPROTOCOL_INFO protocolInfo;

int protocolInfoSize = sizeof(protocolInfo);

if (0 != getsockopt(s, SOL_SOCKET, SO_PROTOCOL_INFO, (char*)&protocolInfo, &protocolInfoSize))
{
exit(1);
}

SOCKADDR_BTH address;

address.addressFamily = AF_BTH;
address.btAddr = 0;
address.serviceClassId = GUID_NULL;
address.port = BT_PORT_ANY;

sockaddr *pAddr = (sockaddr*)&address;

if (0 != bind(s, pAddr, sizeof(SOCKADDR_BTH)))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("succes to bind\n");
}

int size = sizeof(SOCKADDR_BTH);

if (0 != getsockname(s, pAddr, &size))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}

if (0 != listen(s, 10))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("succes to listen\n");
}

WSAQUERYSET service;

memset(&service, 0, sizeof(service));

service.dwSize = sizeof(service);

service.lpszServiceInstanceName = "My Service";
service.lpszComment = "My comment";

//GUID serviceID = OBEXFileTransferServiceClass_UUID;
GUID serviceID = OBEXObjectPushServiceClass_UUID;
service.lpServiceClassId = &serviceID;

service.dwNumberOfCsAddrs = 1;
service.dwNameSpace = NS_BTH;

CSADDR_INFO csAddr;

memset(&csAddr, 0, sizeof(csAddr));

csAddr.LocalAddr.iSockaddrLength = sizeof(SOCKADDR_BTH);
csAddr.LocalAddr.lpSockaddr = pAddr;

csAddr.iSocketType = SOCK_STREAM;
csAddr.iProtocol = BTHPROTO_RFCOMM;

service.lpcsaBuffer = &csAddr;

if (0 != WSASetService(&service, RNRSERVICE_REGISTER, 0))
{
printf("%s\n", GetLastErrorMessage(GetLastError()));
}
else
{
printf("succes to WSASetService\n");
}

SOCKET s1 = accept(s, 0, 0);

unsigned char buffer[2000];

memset(buffer, 0, sizeof(buffer));

printf("receave\n");
int r = recv(s1,(char*)buffer, sizeof(buffer), 0);
printf("readed: %d\n", r);
}
return 0;

}

int main(int argc, char* argv[])
{
//Connect_using_SWA();
//Connect_using_BT_Api();
temp();
return 0;
}

[stoyanj@gmail.com]

Hi,

You have to advertise OBEXObjectPush using WSASetService, but due to a bug or something it would not work the easy way so you have to create the SDP record your self. That’s the whole magic about it