highperfocused/P4wnP1_aloa
1
0
Fork 0
mirror of https://github.com/RoganDawes/P4wnP1_aloa.git synced 2025-11-15 08:32:06 +01:00
Code Issues Packages Projects Releases Wiki Activity

service: fixes for USB gadget concurrent modification

Browse Source
This commit is contained in:
MaMe82
2018-10-31 13:46:48 +01:00
parent 59b136c2dc
commit cfa23614d9
2 changed files with 133 additions and 118 deletions
Download Patch File Download Diff File Expand all files Collapse all files

227
service/SubSysUSB.go
View File

@@ -225,18 +225,18 @@ func ValidateGadgetSetting(gs pb.GadgetSettings) error {
} }
//check endpoint consumption //check endpoint consumption
sum_ep := 0 sumEp := 0
if gs.Use_RNDIS { sum_ep += USB_EP_USAGE_RNDIS } if gs.Use_RNDIS { sumEp += USB_EP_USAGE_RNDIS }
if gs.Use_CDC_ECM { sum_ep += USB_EP_USAGE_CDC_ECM } if gs.Use_CDC_ECM { sumEp += USB_EP_USAGE_CDC_ECM }
if gs.Use_UMS { sum_ep += USB_EP_USAGE_UMS } if gs.Use_UMS { sumEp += USB_EP_USAGE_UMS }
if gs.Use_HID_MOUSE { sum_ep += USB_EP_USAGE_HID_MOUSE } if gs.Use_HID_MOUSE { sumEp += USB_EP_USAGE_HID_MOUSE }
if gs.Use_HID_RAW { sum_ep += USB_EP_USAGE_HID_RAW } if gs.Use_HID_RAW { sumEp += USB_EP_USAGE_HID_RAW }
if gs.Use_HID_KEYBOARD { sum_ep += USB_EP_USAGE_HID_KEYBOARD } if gs.Use_HID_KEYBOARD { sumEp += USB_EP_USAGE_HID_KEYBOARD }
if gs.Use_SERIAL { sum_ep+= USB_EP_USAGE_CDC_SERIAL } if gs.Use_SERIAL { sumEp += USB_EP_USAGE_CDC_SERIAL }
strConsumption := fmt.Sprintf("Gadget Settings consume %v out of %v available USB Endpoints\n", sum_ep, USB_EP_USAGE_MAX) strConsumption := fmt.Sprintf("Gadget Settings consume %v out of %v available USB Endpoints\n", sumEp, USB_EP_USAGE_MAX)
log.Print(strConsumption) log.Print(strConsumption)
if sum_ep > USB_EP_USAGE_MAX { return errors.New(strConsumption)} if sumEp > USB_EP_USAGE_MAX { return errors.New(strConsumption)}
//check if composite gadget is enabled without functions //check if composite gadget is enabled without functions
if gs.Enabled && if gs.Enabled &&
@@ -247,7 +247,7 @@ func ValidateGadgetSetting(gs pb.GadgetSettings) error {
!gs.Use_HID_RAW && !gs.Use_HID_RAW &&
!gs.Use_UMS && !gs.Use_UMS &&
!gs.Use_SERIAL { !gs.Use_SERIAL {
return errors.New("If the composite gadget isn't disabled, as least one function has to be enabled") return errors.New("if the composite gadget isn't disabled, as least one function has to be enabled")
} }
return nil return nil
@@ -294,7 +294,7 @@ func pollForUSBEthernet(timeout time.Duration) error {
time.Sleep(100*time.Millisecond) time.Sleep(100*time.Millisecond)
fmt.Print(".") fmt.Print(".")
} }
return errors.New(fmt.Sprintf("Timeout %v reached before usb0 or usb1 became ready")) return errors.New(fmt.Sprintf("timeout %v reached before usb0 or usb1 became ready", timeout))
} }
@@ -326,61 +326,67 @@ func CheckLibComposite() error {
func getUDCName() (string, error) { func getUDCName() (string, error) {
files, err := ioutil.ReadDir("/sys/class/udc") files, err := ioutil.ReadDir("/sys/class/udc")
if err != nil { if err != nil {
return "", errors.New("Couldn't find working UDC driver") return "", errors.New("couldn't find working UDC driver")
} }
if len(files) < 1 { if len(files) < 1 {
return "", errors.New("Couldn't find working UDC driver") return "", errors.New("couldn't find working UDC driver")
} }
return files[0].Name(), nil return files[0].Name(), nil
} }
func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error) { func (gm *UsbGadgetManager) ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error) {
err = nil err = nil
result = &pb.GadgetSettings{} result = &pb.GadgetSettings{}
//gadget_root := "./test" fmt.Println("ParseGadgetState before lock ...")
gadget_dir := USB_GADGET_DIR_BASE + "/" + gadgetName //Don't parse while deploying
gm.gadgetSettingsLock.Lock()
defer gm.gadgetSettingsLock.Unlock()
fmt.Println("ParseGadgetState beyond lock ...")
gadgetDir := USB_GADGET_DIR_BASE + "/" + gadgetName
//check if root exists, return error otherwise //check if root exists, return error otherwise
if _, err = os.Stat(gadget_dir); os.IsNotExist(err) { if _, err = os.Stat(gadgetDir); os.IsNotExist(err) {
err = errors.New(fmt.Sprintf("Gadget %s doesn't exist", gadgetName)) err = errors.New(fmt.Sprintf("gadget %s doesn't exist", gadgetName))
result = nil result = nil
return return
} }
//ToDo: check if enabled (UDC in functionfs is set to content of /sys/class/udc) //ToDo: check if enabled (UDC in functionfs is set to content of /sys/class/udc)
if res, err := ioutil.ReadFile(gadget_dir + "/idVendor"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/idVendor"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading Vid", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading Vid", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.Vid = strings.TrimSuffix(string(res), "\n") result.Vid = strings.TrimSuffix(string(res), "\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/idProduct"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/idProduct"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading Pid", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading Pid", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.Pid = strings.TrimSuffix(string(res), "\n") result.Pid = strings.TrimSuffix(string(res), "\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/strings/0x409/serialnumber"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/strings/0x409/serialnumber"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading Serial", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading Serial", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.Serial = strings.TrimSuffix(string(res), "\n") result.Serial = strings.TrimSuffix(string(res), "\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/strings/0x409/manufacturer"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/strings/0x409/manufacturer"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading Manufacturer", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading Manufacturer", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.Manufacturer = strings.TrimSuffix(string(res), "\n") result.Manufacturer = strings.TrimSuffix(string(res), "\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/strings/0x409/product"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/strings/0x409/product"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading Product", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading Product", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.Product = strings.TrimSuffix(string(res), "\n") result.Product = strings.TrimSuffix(string(res), "\n")
@@ -389,20 +395,20 @@ func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error)
//Check enabled functions in configuration //Check enabled functions in configuration
//USB RNDIS //USB RNDIS
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/rndis.usb0"); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/rndis.usb0"); !os.IsNotExist(err1) {
result.Use_RNDIS = true result.Use_RNDIS = true
result.RndisSettings = &pb.GadgetSettingsEthernet{} result.RndisSettings = &pb.GadgetSettingsEthernet{}
if res, err := ioutil.ReadFile(gadget_dir + "/functions/rndis.usb0/host_addr"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/rndis.usb0/host_addr"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading RNDIS host_addr", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading RNDIS host_addr", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.RndisSettings.HostAddr = strings.TrimSuffix(string(res), "\000\n") result.RndisSettings.HostAddr = strings.TrimSuffix(string(res), "\000\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/functions/rndis.usb0/dev_addr"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/rndis.usb0/dev_addr"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading RNDIS dev_addr", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading RNDIS dev_addr", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.RndisSettings.DevAddr = strings.TrimSuffix(string(res), "\000\n") result.RndisSettings.DevAddr = strings.TrimSuffix(string(res), "\000\n")
@@ -416,20 +422,20 @@ func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error)
} }
//USB CDC ECM //USB CDC ECM
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/ecm.usb1"); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/ecm.usb1"); !os.IsNotExist(err1) {
result.Use_CDC_ECM = true result.Use_CDC_ECM = true
result.CdcEcmSettings = &pb.GadgetSettingsEthernet{} result.CdcEcmSettings = &pb.GadgetSettingsEthernet{}
if res, err := ioutil.ReadFile(gadget_dir + "/functions/ecm.usb1/host_addr"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/ecm.usb1/host_addr"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading CDC ECM host_addr", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading CDC ECM host_addr", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.CdcEcmSettings.HostAddr = strings.TrimSuffix(string(res), "\000\n") result.CdcEcmSettings.HostAddr = strings.TrimSuffix(string(res), "\000\n")
} }
if res, err := ioutil.ReadFile(gadget_dir + "/functions/ecm.usb1/dev_addr"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/ecm.usb1/dev_addr"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading CDC ECM dev_addr", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading CDC ECM dev_addr", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.CdcEcmSettings.DevAddr = strings.TrimSuffix(string(res), "\000\n") result.CdcEcmSettings.DevAddr = strings.TrimSuffix(string(res), "\000\n")
@@ -444,33 +450,33 @@ func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error)
} }
//USB serial //USB serial
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/acm.GS0"); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/acm.GS0"); !os.IsNotExist(err1) {
result.Use_SERIAL = true result.Use_SERIAL = true
} }
//USB HID Keyboard //USB HID Keyboard
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/"+USB_FUNCTION_HID_KEYBOARD_name); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/"+USB_FUNCTION_HID_KEYBOARD_name); !os.IsNotExist(err1) {
result.Use_HID_KEYBOARD = true result.Use_HID_KEYBOARD = true
} }
//USB HID Mouse //USB HID Mouse
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/"+USB_FUNCTION_HID_MOUSE_name); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/"+USB_FUNCTION_HID_MOUSE_name); !os.IsNotExist(err1) {
result.Use_HID_MOUSE = true result.Use_HID_MOUSE = true
} }
//USB HID Raw //USB HID Raw
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/"+USB_FUNCTION_HID_RAW_name); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/"+USB_FUNCTION_HID_RAW_name); !os.IsNotExist(err1) {
result.Use_HID_RAW = true result.Use_HID_RAW = true
} }
//USB Mass Storage //USB Mass Storage
if _, err1 := os.Stat(gadget_dir+"/configs/c.1/mass_storage.ms1"); !os.IsNotExist(err1) { if _, err1 := os.Stat(gadgetDir +"/configs/c.1/mass_storage.ms1"); !os.IsNotExist(err1) {
result.Use_UMS = true result.Use_UMS = true
result.UmsSettings = &pb.GadgetSettingsUMS{} result.UmsSettings = &pb.GadgetSettingsUMS{}
//Check if running as CD-Rom //Check if running as CD-Rom
if res, err := ioutil.ReadFile(gadget_dir + "/functions/mass_storage.ms1/lun.0/cdrom"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/mass_storage.ms1/lun.0/cdrom"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading USB Mass Storage cdrom emulation state", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading USB Mass Storage cdrom emulation state", gadgetName))
return nil, err1 return nil, err1
} else { } else {
if strings.HasPrefix(string(res), "1") { if strings.HasPrefix(string(res), "1") {
@@ -479,8 +485,8 @@ func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error)
} }
//Check name of backing file //Check name of backing file
if res, err := ioutil.ReadFile(gadget_dir + "/functions/mass_storage.ms1/lun.0/file"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/functions/mass_storage.ms1/lun.0/file"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading USB Mass Storage image file setting", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading USB Mass Storage image file setting", gadgetName))
return nil, err1 return nil, err1
} else { } else {
result.UmsSettings.File = strings.TrimSuffix(string(res), "\000\n") result.UmsSettings.File = strings.TrimSuffix(string(res), "\000\n")
@@ -488,15 +494,15 @@ func ParseGadgetState(gadgetName string) (result *pb.GadgetSettings, err error)
} }
//check if UDC is set (Gadget enabled) //check if UDC is set (Gadget enabled)
udc_name, _ := getUDCName() udcName, _ := getUDCName()
if res, err := ioutil.ReadFile(gadget_dir + "/UDC"); err != nil { if res, err := ioutil.ReadFile(gadgetDir + "/UDC"); err != nil {
err1 := errors.New(fmt.Sprintf("Gadget %s error reading UDC", gadgetName)) err1 := errors.New(fmt.Sprintf("gadget %s error reading UDC", gadgetName))
return nil, err1 return nil, err1
} else { } else {
udc_name_set := strings.TrimSuffix(string(res), "\n") udcNameSet := strings.TrimSuffix(string(res), "\n")
//log.Printf("UDC test: udc_name_set %s, udc_name %s", udc_name_set, udc_name) //log.Printf("UDC test: udcNameSet %s, udcName %s", udcNameSet, udcName)
if udc_name == udc_name_set { if udcName == udcNameSet {
result.Enabled = true result.Enabled = true
} }
} }
@@ -511,7 +517,7 @@ func MountUMSFile(filename string) error {
funcdir := USB_GADGET_DIR + "/functions/mass_storage.ms1" funcdir := USB_GADGET_DIR + "/functions/mass_storage.ms1"
err := ioutil.WriteFile(funcdir+"/lun.0/file", []byte(filename), os.ModePerm) err := ioutil.WriteFile(funcdir+"/lun.0/file", []byte(filename), os.ModePerm)
if err != nil { if err != nil {
return errors.New(fmt.Sprintf("Settings backing file for USB Mass Storage failed: %v", err)) return errors.New(fmt.Sprintf("settings backing file for USB Mass Storage failed: %v", err))
} }
return nil return nil
} }
@@ -521,18 +527,23 @@ func (gm *UsbGadgetManager) DeployGadgetSettings(settings *pb.GadgetSettings) er
return ErrUsbNotUsable return ErrUsbNotUsable
} }
fmt.Println("DeployGadgetSettings before lock ...")
//Lock, only one change at a time //Lock, only one change at a time
gm.gadgetSettingsLock.Lock() gm.gadgetSettingsLock.Lock()
defer gm.gadgetSettingsLock.Unlock() defer gm.gadgetSettingsLock.Unlock()
fmt.Println("DeployGadgetSettings beyond lock ...")
fmt.Println("... deconstruct old gadget")
gm.DestroyGadget(USB_GADGET_NAME)
var usesUSBEthernet bool var usesUSBEthernet bool
//gadget_root := "./test" gadgetRoot := USB_GADGET_DIR_BASE
gadget_root := USB_GADGET_DIR_BASE
//check if root exists, return error otherwise //check if root exists, return error otherwise
if _, err := os.Stat(gadget_root); os.IsNotExist(err) { if _, err := os.Stat(gadgetRoot); os.IsNotExist(err) {
return errors.New("Configfs path for gadget doesn't exist") return errors.New("configfs path for gadget doesn't exist")
} }
//ToDo: check if UDC is present and usable //ToDo: check if UDC is present and usable
@@ -719,12 +730,12 @@ func (gm *UsbGadgetManager) DeployGadgetSettings(settings *pb.GadgetSettings) er
//get UDC driver name and bind to gadget //get UDC driver name and bind to gadget
if settings.Enabled { if settings.Enabled {
udc_name, err := getUDCName() udcName, err := getUDCName()
if err != nil { if err != nil {
return err return err
} }
log.Printf("Enabeling gadget for UDC: %s\n", udc_name) log.Printf("Enabeling gadget for UDC: %s\n", udcName)
if err = ioutil.WriteFile(USB_GADGET_DIR+"/UDC", []byte(udc_name), os.ModePerm); err != nil { if err = ioutil.WriteFile(USB_GADGET_DIR+"/UDC", []byte(udcName), os.ModePerm); err != nil {
return err return err
} }
@@ -808,23 +819,25 @@ func enumDevicePath(funcName string) (devPath string, err error){
} }
func (gm *UsbGadgetManager) DestroyAllGadgets() error { func (gm *UsbGadgetManager) DestroyAllGadgets() error {
//gadget_root := "./test"
gadget_root := USB_GADGET_DIR_BASE //gadgetRoot := "./test"
gadgetRoot := USB_GADGET_DIR_BASE
//check if root exists, return error otherwise //check if root exists, return error otherwise
if _, err := os.Stat(gadget_root); os.IsNotExist(err) { if _, err := os.Stat(gadgetRoot); os.IsNotExist(err) {
return errors.New("Configfs path for gadget doesn't exist") return errors.New("configfs path for gadget doesn't exist")
} }
gadget_dirs, err := ioutil.ReadDir(gadget_root) gadgetDirs, err := ioutil.ReadDir(gadgetRoot)
if err != nil { if err != nil {
return errors.New("No gadgets") return errors.New("no gadgets")
} }
for _, gadget_dir_obj := range gadget_dirs { for _, gadgetDirObj := range gadgetDirs {
gadget_name := gadget_dir_obj.Name() gadgetName := gadgetDirObj.Name()
log.Println("Found gadget: " + gadget_name) log.Println("Found gadget: " + gadgetName)
err = DestroyGadget(gadget_name)
err = gm.DestroyGadget(gadgetName)
if err != nil { if err != nil {
log.Println(err) //don't return, continue with next log.Println(err) //don't return, continue with next
} }
@@ -837,72 +850,74 @@ func (gm *UsbGadgetManager) DestroyAllGadgets() error {
return nil return nil
} }
func DestroyGadget(Gadget_name string) error { func (gm *UsbGadgetManager) DestroyGadget(gadgetName string) error {
//gadget_root := "./test"
gadget_dir := USB_GADGET_DIR_BASE + "/" + Gadget_name
gadgetDir := USB_GADGET_DIR_BASE + "/" + gadgetName
//check if root exists, return error otherwise //check if root exists, return error otherwise
if _, err := os.Stat(USB_GADGET_DIR_BASE); os.IsNotExist(err) { if _, err := os.Stat(USB_GADGET_DIR_BASE); os.IsNotExist(err) {
return errors.New("Gadget " + Gadget_name + " doesn't exist") return errors.New("Gadget " + gadgetName + " doesn't exist")
} }
log.Println("Deconstructing gadget " + Gadget_name + "...") log.Println("Deconstructing gadget " + gadgetName + "...")
//Assure gadget gets unbound from UDC //Assure gadget gets unbound from UDC
ioutil.WriteFile(gadget_dir+"/UDC", []byte("\x00"), os.ModePerm) ioutil.WriteFile(gadgetDir+"/UDC", []byte("\x00"), os.ModePerm)
//Iterate over configurations //Iterate over configurations
config_dirs, _ := ioutil.ReadDir(gadget_dir + "/configs") configDirs, _ := ioutil.ReadDir(gadgetDir + "/configs")
for _, conf_dir_obj := range config_dirs { for _, confDirObj := range configDirs {
conf_name := conf_dir_obj.Name() confName := confDirObj.Name()
conf_dir := gadget_dir + "/configs/" + conf_name confDir := gadgetDir + "/configs/" + confName
log.Println("Found config: " + conf_name) log.Println("Found config: " + confName)
//find linked functions //find linked functions
conf_content, _ := ioutil.ReadDir(conf_dir) confContents, _ := ioutil.ReadDir(confDir)
for _, function := range conf_content { for _, function := range confContents {
//Remove link from function to config //Remove link from function to config
if function.Mode()&os.ModeSymlink > 0 { if function.Mode()&os.ModeSymlink > 0 {
log.Println("\tRemoving function " + function.Name() + " from config " + conf_name) log.Println("\tRemoving function " + function.Name() + " from config " + confName)
os.Remove(conf_dir + "/" + function.Name()) os.Remove(confDir + "/" + function.Name())
} }
} }
//find string directories in config //find string directories in config
strings_content, _ := ioutil.ReadDir(conf_dir + "/strings") stringsContents, _ := ioutil.ReadDir(confDir + "/strings")
for _, str := range strings_content { for _, str := range stringsContents {
string_dir := str.Name() stringDir := str.Name()
//Remove string from config //Remove string from config
log.Println("\tRemoving string dir '" + string_dir + "' from configuration") log.Println("\tRemoving string dir '" + stringDir + "' from configuration")
os.Remove(conf_dir + "/strings/" + string_dir) os.Remove(confDir + "/strings/" + stringDir)
} }
//Check if there's an OS descriptor refering this config //Check if there's an OS descriptor refering this config
if _, err := os.Stat(gadget_dir + "/os_desc/" + conf_name); !os.IsNotExist(err) { if _, err := os.Stat(gadgetDir + "/os_desc/" + confName); !os.IsNotExist(err) {
log.Println("\tDeleting link to '" + conf_name + "' from gadgets OS descriptor") log.Println("\tDeleting link to '" + confName + "' from gadgets OS descriptor")
os.Remove(gadget_dir + "/os_desc/" + conf_name) os.Remove(gadgetDir + "/os_desc/" + confName)
} }
// remove config folder, finally // remove config folder, finally
log.Println("\tDeleting configuration '" + conf_name + "'") log.Println("\tDeleting configuration '" + confName + "'")
os.Remove(conf_dir) os.Remove(confDir)
} }
// remove functions // remove functions
log.Println("Removing functions from '" + Gadget_name + "'") log.Println("Removing functions from '" + gadgetName + "'")
os.RemoveAll(gadget_dir + "/functions/") os.RemoveAll(gadgetDir + "/functions/")
//find string directories in gadget //find string directories in gadget
strings_content, _ := ioutil.ReadDir(gadget_dir + "/strings") stringsContents, _ := ioutil.ReadDir(gadgetDir + "/strings")
for _, str := range strings_content { for _, str := range stringsContents {
string_dir := str.Name() stringDir := str.Name()
//Remove string from config //Remove string from config
log.Println("Removing string dir '" + string_dir + "' from " + Gadget_name) log.Println("Removing string dir '" + stringDir + "' from " + gadgetName)
os.Remove(gadget_dir + "/strings/" + string_dir) os.Remove(gadgetDir + "/strings/" + stringDir)
} }
//And now remove the gadget itself //And now remove the gadget itself
log.Println("Removing gadget " + Gadget_name) log.Println("Removing gadget " + gadgetName)
os.Remove(gadget_dir) os.Remove(gadgetDir)
return nil return nil
} }

24
service/rpc_server.go
View File

@@ -292,7 +292,7 @@ func (s *server) DeployStoredUSBSettings(ctx context.Context, m *pb.StringMessag
} }
func (s *server) StoreDeployedUSBSettings(ctx context.Context, m *pb.StringMessage) (e *pb.Empty, err error) { func (s *server) StoreDeployedUSBSettings(ctx context.Context, m *pb.StringMessage) (e *pb.Empty, err error) {
gstate, err := ParseGadgetState(USB_GADGET_NAME) gstate, err := s.rootSvc.SubSysUSB.ParseGadgetState(USB_GADGET_NAME)
if err != nil { return &pb.Empty{},err } if err != nil { return &pb.Empty{},err }
return s.StoreUSBSettings(ctx, &pb.USBRequestSettingsStorage{ return s.StoreUSBSettings(ctx, &pb.USBRequestSettingsStorage{
@@ -766,28 +766,28 @@ func (s *server) MountUMSFile(ctx context.Context, gsu *pb.GadgetSettingsUMS) (*
} }
func (s *server) GetDeployedGadgetSetting(ctx context.Context, e *pb.Empty) (gs *pb.GadgetSettings, err error) { func (s *server) GetDeployedGadgetSetting(ctx context.Context, e *pb.Empty) (gs *pb.GadgetSettings, err error) {
gs, err = ParseGadgetState(USB_GADGET_NAME) log.Printf("Called get deployed gadget settings\n")
gs, err = s.rootSvc.SubSysUSB.ParseGadgetState(USB_GADGET_NAME)
if err != nil {
log.Printf("Error parsing current gadget config: %v", err)
return
}
gs.DevPathHidKeyboard = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_KEYBOARD_name] gs.DevPathHidKeyboard = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_KEYBOARD_name]
gs.DevPathHidMouse = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_MOUSE_name] gs.DevPathHidMouse = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_MOUSE_name]
gs.DevPathHidRaw = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_RAW_name] gs.DevPathHidRaw = s.rootSvc.SubSysUSB.State.DevicePath[USB_FUNCTION_HID_RAW_name]
if err == nil {
j_usbset, _ := json.Marshal(gs)
log.Printf("Gadget settings requested %v", string(j_usbset))
} else {
log.Printf("Error parsing current gadget config: %v", err)
}
return return
} }
func (s *server) DeployGadgetSetting(context.Context, *pb.Empty) (gs *pb.GadgetSettings, err error) { func (s *server) DeployGadgetSetting(context.Context, *pb.Empty) (gs *pb.GadgetSettings, err error) {
log.Printf("Called DeployGadgetSettings\n")
defer s.rootSvc.SubSysEvent.Emit(ConstructEventNotifyStateChange(common_web.STATE_CHANGE_EVT_TYPE_USB)) defer s.rootSvc.SubSysEvent.Emit(ConstructEventNotifyStateChange(common_web.STATE_CHANGE_EVT_TYPE_USB))
gs_backup,_ := ParseGadgetState(USB_GADGET_NAME) gs_backup,_ := s.rootSvc.SubSysUSB.ParseGadgetState(USB_GADGET_NAME)
//ToDo: Former gadgets are destroyed without testing if there're changes, this should be aborted if GadgetSettingsState == GetDeployedGadgetSettings() //ToDo: Former gadgets are destroyed without testing if there're changes, this should be aborted if GadgetSettingsState == GetDeployedGadgetSettings()
DestroyGadget(USB_GADGET_NAME) //s.rootSvc.SubSysUSB.DestroyGadget(USB_GADGET_NAME) //already done by deploy
errg := s.rootSvc.SubSysUSB.DeployGadgetSettings(s.rootSvc.SubSysUSB.State.UndeployedGadgetSettings) errg := s.rootSvc.SubSysUSB.DeployGadgetSettings(s.rootSvc.SubSysUSB.State.UndeployedGadgetSettings)
err = nil err = nil
@@ -796,7 +796,7 @@ func (s *server) DeployGadgetSetting(context.Context, *pb.Empty) (gs *pb.GadgetS
s.rootSvc.SubSysUSB.DeployGadgetSettings(gs_backup) //We don't catch the error, as the old settings should have been working s.rootSvc.SubSysUSB.DeployGadgetSettings(gs_backup) //We don't catch the error, as the old settings should have been working
} }
gs, _ = ParseGadgetState(USB_GADGET_NAME) //Return settings from deployed gadget gs, _ = s.rootSvc.SubSysUSB.ParseGadgetState(USB_GADGET_NAME) //Return settings from deployed gadget
return return
} }