status_t BnDemoImpl::onTransact( uint32_t code,
                                    const Parcel& data,
                                    Parcel* reply,
                                    uint32_t flags)
{
    pid_t pid = IPCThreadState::self()->getCallingPid();
    uid_t uid = IPCThreadState::self()->getCallingUid();
    cout << "called from pid: " << pid << ", uid: " << uid << ", code: " << code << endl;

    switch(code) {
    case DEMO_GET_PID:
        reply->writeUint64(pid);
        return OK;
        break;

    case DEMO_GET_UID:
        reply->writeUint64(uid);
        return OK;
        break;

    case DEMO_LIST_SERVICES:
    {
        vector<String16> services = listServices();
        reply->writeString16Vector(services);
        return OK;
    }
        break;

    default:
        return BBinder::onTransact(code, data, reply, flags);
        break;
    }
};
Beispiel #2
0
int main(int argc, char** argv)
{
  //
  // Be sure all files are only readable
  // by the user.
  //

  umask(0077);

  char *programName = NULL;

  if (argc > 1)
  {
    switch(parseArguments(programName, argc, argv))
    {
    case LIST:
      if (listServices(programName))
      {
        return 1;
      }
      break;
    case START:
      if (startService(programName, argc, argv))
      {
        return 1;
      }
      break;
    case STOP:
      if (stopService(programName, argc, argv))
      {
        return 1;
      }
      break;
    case CLEANUP:
      if (cleanupDirectories())
      {
        return 1;
      }
      break;
    case CHECK:
      logUser("NXSERVICE - is running");
      break;
    case PROGRAM_VERSION:
      logUser("NXSERVICE - version %s", VERSION);
      break;
    case UNKNOWN:
    default:
      logUser("Error: unknown parameter.");
      return 1;
    }
  }
  else
  {
    logUser("Error: Wrong parameters.");
    return 1;
  }

  return 0;
}
status_t BnServiceManager::onTransact(
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
    //printf("ServiceManager received: "); data.print();
    switch(code) {
        case GET_SERVICE_TRANSACTION: {
            CHECK_INTERFACE(IServiceManager, data, reply);
            String16 which = data.readString16();
            sp<IBinder> b = const_cast<BnServiceManager*>(this)->getService(which);
            reply->writeStrongBinder(b);
            return NO_ERROR;
        } break;
        case CHECK_SERVICE_TRANSACTION: {
            CHECK_INTERFACE(IServiceManager, data, reply);
            String16 which = data.readString16();
            sp<IBinder> b = const_cast<BnServiceManager*>(this)->checkService(which);
            reply->writeStrongBinder(b);
            return NO_ERROR;
        } break;
        case ADD_SERVICE_TRANSACTION: {
            CHECK_INTERFACE(IServiceManager, data, reply);
            String16 which = data.readString16();
            sp<IBinder> b = data.readStrongBinder();
            status_t err = addService(which, b);
            reply->writeInt32(err);
            return NO_ERROR;
        } break;
        case LIST_SERVICES_TRANSACTION: {
            CHECK_INTERFACE(IServiceManager, data, reply);
            Vector<String16> list = listServices();
            const size_t N = list.size();
            reply->writeInt32(N);
            for (size_t i=0; i<N; i++) {
                reply->writeString16(list[i]);
            }
            return NO_ERROR;
        } break;
        default:
            return BBinder::onTransact(code, data, reply, flags);
    }
}
Beispiel #4
0
int main(int argc, char ** argv)
{
	char * descURL = NULL;
	int option_index = 0;
	int c;
	int devid = -1;
	char arguments[1025]; arguments[0]='\0';
	char action[129]; action[0]='\0';
	char verbose = 0;

	unsigned int operation = OP_NONE;

	if(argc == 1)
	{
		printUsage(argv[0]);
		return -1;
	}

	while(1){
		c = getopt_long(argc,argv,"dlva:p:",long_options,&option_index);

		if(c == -1)
			break;

		switch(c){
		case 'd': operation = OP_DISCOVER; break;
		case 'l': operation = OP_LIST; break;
		case 'a': operation = OP_CALLOP; if(optarg) strncpy(action,optarg,128); break;
		case 'p': if(optarg) strncpy(arguments,optarg,1024); break;
		case 'v': verbose = 1; break;
		default: printUsage(argv[0]); return 0;
		}
	}
	
	if(verbose) printf("Universal Plug and Play IGD Tool v0.1\n  João Paulo Barraca <*****@*****.**>\n\n");
	if(operation == OP_NONE)
		return 0;

	descURL = upnpDiscover(5000);	// timeout = 5secs

	if(descURL)
	{
		struct IGDdatas *data = (struct IGDdatas*) malloc(sizeof(struct IGDdatas));
		struct UPNPUrls urls;

		memset(data, 0, sizeof(struct IGDdatas));
		memset(&urls, 0, sizeof(struct UPNPUrls));

		char * descXML;
		int descXMLsize = 0;
		descXML = miniwget(descURL, &descXMLsize);

		parserootdesc(descXML, descXMLsize, data);

		if(descXML)
		{

			switch(operation)
			{
			case OP_CALLOP:
				callUPNPVariable(data,action,arguments, verbose);
				break;
			case OP_LIST:
				listServices(data,devid,verbose); 
				break;
			case OP_DISCOVER:
				listDevices(data);		
				break;
			default: printf("Error: Action not implemented (yet)!\n"); break;
			}
			free(descXML);
		}
		else
		{
			printf("Error: Cannot get XML description of the device.\n");
		}
		freeIGD(data);
		free(descURL);
	}
	else
	{
		fprintf(stderr, "Error: No IGD UPnP Device found on the network !\n");
	}
	return 0;
}