gdb-xds.go

   1 /*
   2  * Copyright (C) 2017 "IoT.bzh"
   3  * Author Sebastien Douheret <sebastien@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *   http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 package main
  20
  21 import (
  22         "encoding/json"
  23         "fmt"
  24         "os"
  25         "regexp"
  26         "strconv"
  27         "strings"
  28         "syscall"
  29
  30         "github.com/Sirupsen/logrus"
  31         "github.com/iotbzh/xds-agent/lib/xaapiv1"
  32         common "github.com/iotbzh/xds-common/golib"
  33         sio_client "github.com/sebd71/go-socket.io-client"
  34 )
  35
  36 // GdbXds - Implementation of IGDB used to interfacing XDS
  37 type GdbXds struct {
  38         log       *logrus.Logger
  39         ccmd      string
  40         aargs     []string
  41         eenv      []string
  42         agentURL  string
  43         serverURL string
  44         prjID     string
  45         sdkID     string
  46         rPath     string
  47         listPrj   bool
  48         cmdID     string
  49         xGdbPid   string
  50
  51         httpCli *common.HTTPClient
  52         ioSock  *sio_client.Client
  53
  54         projects []xaapiv1.ProjectConfig
  55
  56         // callbacks
  57         cbOnError      func(error)
  58         cbOnDisconnect func(error)
  59         cbRead         func(timestamp, stdout, stderr string)
  60         cbInferiorRead func(timestamp, stdout, stderr string)
  61         cbOnExit       func(code int, err error)
  62 }
  63
  64 // NewGdbXds creates a new instance of GdbXds
  65 func NewGdbXds(log *logrus.Logger, args []string, env []string) *GdbXds {
  66         return &GdbXds{
  67                 log:     log,
  68                 ccmd:    "exec $GDB", // var set by environment-setup-xxx script
  69                 aargs:   args,
  70                 eenv:    env,
  71                 httpCli: nil,
  72                 ioSock:  nil,
  73                 xGdbPid: strconv.Itoa(os.Getpid()),
  74         }
  75 }
  76
  77 // SetConfig set additional config fields
  78 func (g *GdbXds) SetConfig(name string, value interface{}) error {
  79         switch name {
  80         case "agentURL":
  81                 g.agentURL = value.(string)
  82         case "serverURL":
  83                 g.serverURL = value.(string)
  84         case "prjID":
  85                 g.prjID = value.(string)
  86         case "sdkID":
  87                 g.sdkID = value.(string)
  88         case "rPath":
  89                 g.rPath = value.(string)
  90         case "listProject":
  91                 g.listPrj = value.(bool)
  92         default:
  93                 return fmt.Errorf("Unknown %s field", name)
  94         }
  95         return nil
  96 }
  97
  98 // Init initializes gdb XDS
  99 func (g *GdbXds) Init() (int, error) {
 100
 101         // Reset command ID (also used to enable sending of signals)
 102         g.cmdID = ""
 103
 104         // Define HTTP and WS url
 105         baseURL := g.agentURL
 106
 107         // Allow to only set port number
 108         if match, _ := regexp.MatchString("^([0-9]+)$", baseURL); match {
 109                 baseURL = "http://localhost:" + g.agentURL
 110         }
 111         // Add http prefix if missing
 112         if baseURL != "" && !strings.HasPrefix(g.agentURL, "http://") {
 113                 baseURL = "http://" + g.agentURL
 114         }
 115
 116         // Create HTTP client
 117         g.log.Infoln("Connect HTTP client on ", baseURL)
 118         conf := common.HTTPClientConfig{
 119                 URLPrefix:           "/api/v1",
 120                 HeaderClientKeyName: "Xds-Agent-Sid",
 121                 CsrfDisable:         true,
 122                 LogOut:              g.log.Out,
 123                 LogLevel:            common.HTTPLogLevelWarning,
 124         }
 125         c, err := common.HTTPNewClient(baseURL, conf)
 126         if err != nil {
 127                 errmsg := err.Error()
 128                 if m, err := regexp.MatchString("Get http.?://", errmsg); m && err == nil {
 129                         i := strings.LastIndex(errmsg, ":")
 130                         errmsg = "Cannot connection to " + baseURL + errmsg[i:]
 131                 }
 132                 return int(syscallEBADE), fmt.Errorf(errmsg)
 133         }
 134         g.httpCli = c
 135         g.httpCli.SetLogLevel(g.log.Level.String())
 136         g.log.Infoln("HTTP session ID:", g.httpCli.GetClientID())
 137
 138         // First call to check that xds-agent and server are alive
 139         ver := xaapiv1.XDSVersion{}
 140         if err := g.httpCli.Get("/version", &ver); err != nil {
 141                 return int(syscallEBADE), err
 142         }
 143         g.log.Infoln("XDS agent & server version:", ver)
 144
 145         // Get current config and update connection to server when needed
 146         xdsConf := xaapiv1.APIConfig{}
 147         if err := g.httpCli.Get("/config", &xdsConf); err != nil {
 148                 return int(syscallEBADE), err
 149         }
 150         // FIXME: add multi-servers support
 151         idx := 0
 152         svrCfg := xdsConf.Servers[idx]
 153         if g.serverURL != "" && (svrCfg.URL != g.serverURL || !svrCfg.Connected) {
 154                 svrCfg.URL = g.serverURL
 155                 svrCfg.ConnRetry = 10
 156                 newCfg := xaapiv1.APIConfig{}
 157                 if err := g.httpCli.Post("/config", xdsConf, &newCfg); err != nil {
 158                         return int(syscallEBADE), err
 159                 }
 160
 161         } else if !svrCfg.Connected {
 162                 return int(syscallEBADE), fmt.Errorf("XDS server not connected (url=%s)", svrCfg.URL)
 163         }
 164
 165         // Get XDS projects list
 166         var data []byte
 167         if err := g.httpCli.HTTPGet("/projects", &data); err != nil {
 168                 return int(syscallEBADE), err
 169         }
 170
 171         g.log.Infof("Result of /projects: %v", string(data[:]))
 172         g.projects = []xaapiv1.ProjectConfig{}
 173         errMar := json.Unmarshal(data, &g.projects)
 174         if errMar != nil {
 175                 g.log.Errorf("Cannot decode projects configuration: %s", errMar.Error())
 176         }
 177
 178         // Check mandatory args
 179         if g.prjID == "" || g.listPrj {
 180                 return g.printProjectsList()
 181         }
 182
 183         // Create io Websocket client
 184         g.log.Infoln("Connecting IO.socket client on ", baseURL)
 185
 186         opts := &sio_client.Options{
 187                 Transport: "websocket",
 188                 Header:    make(map[string][]string),
 189         }
 190         opts.Header["XDS-AGENT-SID"] = []string{c.GetClientID()}
 191
 192         iosk, err := sio_client.NewClient(baseURL, opts)
 193         if err != nil {
 194                 e := fmt.Sprintf("IO.socket connection error: " + err.Error())
 195                 return int(syscall.ECONNABORTED), fmt.Errorf(e)
 196         }
 197         g.ioSock = iosk
 198
 199         iosk.On("error", func(err error) {
 200                 if g.cbOnError != nil {
 201                         g.cbOnError(err)
 202                 }
 203         })
 204
 205         iosk.On("disconnection", func(err error) {
 206                 if g.cbOnDisconnect != nil {
 207                         g.cbOnDisconnect(err)
 208                 }
 209         })
 210
 211         // SEB gdbPid := ""
 212         iosk.On(xaapiv1.ExecOutEvent, func(ev xaapiv1.ExecOutMsg) {
 213                 if g.cbRead != nil {
 214                         g.cbRead(ev.Timestamp, ev.Stdout, ev.Stderr)
 215                         /*
 216                                 stdout := ev.Stdout
 217                                 // SEB
 218                                 //New Thread 15139
 219                                 if strings.Contains(stdout, "pid = ") {
 220                                         re := regexp.MustCompile("pid = ([0-9]+)")
 221                                         if res := re.FindAllStringSubmatch(stdout, -1); len(res) > 0 {
 222                                                 gdbPid = res[0][1]
 223                                         }
 224                                         g.log.Errorf("SEB FOUND THREAD in '%s' => gdbPid=%s", stdout, gdbPid)
 225                                 }
 226                                 if gdbPid != "" && g.xGdbPid != "" && strings.Contains(stdout, gdbPid) {
 227                                         g.log.Errorf("SEB THREAD REPLACE 1 stdout=%s", stdout)
 228                                         stdout = strings.Replace(stdout, gdbPid, g.xGdbPid, -1)
 229                                         g.log.Errorf("SEB THREAD REPLACE 2 stdout=%s", stdout)
 230                                 }
 231
 232                                 g.cbRead(ev.Timestamp, stdout, ev.Stderr)
 233                         */
 234                 }
 235         })
 236
 237         iosk.On(xaapiv1.ExecInferiorOutEvent, func(ev xaapiv1.ExecOutMsg) {
 238                 if g.cbInferiorRead != nil {
 239                         g.cbInferiorRead(ev.Timestamp, ev.Stdout, ev.Stderr)
 240                 }
 241         })
 242
 243         iosk.On(xaapiv1.ExecExitEvent, func(ev xaapiv1.ExecExitMsg) {
 244                 if g.cbOnExit != nil {
 245                         g.cbOnExit(ev.Code, ev.Error)
 246                 }
 247         })
 248
 249         return 0, nil
 250 }
 251
 252 // Close frees allocated objects and close opened connections
 253 func (g *GdbXds) Close() error {
 254         g.cbOnDisconnect = nil
 255         g.cbOnError = nil
 256         g.cbOnExit = nil
 257         g.cbRead = nil
 258         g.cbInferiorRead = nil
 259         g.cmdID = ""
 260
 261         return nil
 262 }
 263
 264 // Start sends a request to start remotely gdb within xds-server
 265 func (g *GdbXds) Start(inferiorTTY bool) (int, error) {
 266         var err error
 267         var project *xaapiv1.ProjectConfig
 268
 269         // Retrieve the project definition
 270         for _, f := range g.projects {
 271                 // check as prefix to support short/partial id name
 272                 if strings.HasPrefix(f.ID, g.prjID) {
 273                         project = &f
 274                         break
 275                 }
 276         }
 277
 278         // Auto setup rPath if needed
 279         if g.rPath == "" && project != nil {
 280                 cwd, err := os.Getwd()
 281                 if err == nil {
 282                         fldRp := project.ClientPath
 283                         if !strings.HasPrefix(fldRp, "/") {
 284                                 fldRp = "/" + fldRp
 285                         }
 286                         log.Debugf("Try to auto-setup rPath: cwd=%s ; ClientPath=%s", cwd, fldRp)
 287                         if sp := strings.SplitAfter(cwd, fldRp); len(sp) == 2 {
 288                                 g.rPath = strings.Trim(sp[1], "/")
 289                                 g.log.Debugf("Auto-setup rPath to: '%s'", g.rPath)
 290                         }
 291                 }
 292         }
 293
 294         // Enable workaround about inferior output with gdbserver connection
 295         // except if XDS_GDBSERVER_OUTPUT_NOFIX is defined
 296         _, gdbserverNoFix := os.LookupEnv("XDS_GDBSERVER_OUTPUT_NOFIX")
 297
 298         args := xaapiv1.ExecArgs{
 299                 ID:              g.prjID,
 300                 SdkID:           g.sdkID,
 301                 Cmd:             g.ccmd,
 302                 Args:            g.aargs,
 303                 Env:             g.eenv,
 304                 RPath:           g.rPath,
 305                 TTY:             inferiorTTY,
 306                 TTYGdbserverFix: !gdbserverNoFix,
 307                 CmdTimeout:      -1, // no timeout, end when stdin close or command exited normally
 308         }
 309
 310         g.log.Infof("POST %s/exec %v", g.agentURL, args)
 311         res := xaapiv1.ExecResult{}
 312         err = g.httpCli.Post("/exec", args, &res)
 313         if err != nil {
 314                 return int(syscall.EAGAIN), err
 315         }
 316         if res.CmdID == "" {
 317                 return int(syscallEBADE), fmt.Errorf("null CmdID")
 318         }
 319         g.cmdID = res.CmdID
 320
 321         return 0, nil
 322 }
 323
 324 // Cmd returns the command name
 325 func (g *GdbXds) Cmd() string {
 326         return g.ccmd
 327 }
 328
 329 // Args returns the list of arguments
 330 func (g *GdbXds) Args() []string {
 331         return g.aargs
 332 }
 333
 334 // Env returns the list of environment variables
 335 func (g *GdbXds) Env() []string {
 336         return g.eenv
 337 }
 338
 339 // OnError is called on a WebSocket error
 340 func (g *GdbXds) OnError(f func(error)) {
 341         g.cbOnError = f
 342 }
 343
 344 // OnDisconnect is called when WebSocket disconnection
 345 func (g *GdbXds) OnDisconnect(f func(error)) {
 346         g.cbOnDisconnect = f
 347 }
 348
 349 // OnExit calls when exit event is received
 350 func (g *GdbXds) OnExit(f func(code int, err error)) {
 351         g.cbOnExit = f
 352 }
 353
 354 // Read calls when a message/string event is received on stdout or stderr
 355 func (g *GdbXds) Read(f func(timestamp, stdout, stderr string)) {
 356         g.cbRead = f
 357 }
 358
 359 // InferiorRead calls when a message/string event is received on stdout or stderr of the debugged program (IOW inferior)
 360 func (g *GdbXds) InferiorRead(f func(timestamp, stdout, stderr string)) {
 361         g.cbInferiorRead = f
 362 }
 363
 364 // Write writes message/string into gdb stdin
 365 func (g *GdbXds) Write(args ...interface{}) error {
 366         return g.ioSock.Emit(xaapiv1.ExecInEvent, args...)
 367 }
 368
 369 // SendSignal is used to send a signal to remote process/gdb
 370 func (g *GdbXds) SendSignal(sig os.Signal) error {
 371         if g.cmdID == "" {
 372                 return fmt.Errorf("cmdID not set")
 373         }
 374
 375         sigArg := xaapiv1.ExecSignalArgs{
 376                 CmdID:  g.cmdID,
 377                 Signal: sig.String(),
 378         }
 379         g.log.Debugf("POST /signal %v", sigArg)
 380         return g.httpCli.Post("/signal", sigArg, nil)
 381 }
 382
 383 //***** Private functions *****
 384
 385 func (g *GdbXds) printProjectsList() (int, error) {
 386         msg := ""
 387         if len(g.projects) > 0 {
 388                 msg += "List of existing projects (use: export XDS_PROJECT_ID=<< ID >>): \n"
 389                 msg += "  ID\t\t\t\t | Label"
 390                 for _, f := range g.projects {
 391                         msg += fmt.Sprintf("\n  %s\t | %s", f.ID, f.Label)
 392                         if f.DefaultSdk != "" {
 393                                 msg += fmt.Sprintf("\t(default SDK: %s)", f.DefaultSdk)
 394                         }
 395                 }
 396                 msg += "\n"
 397         }
 398
 399         // FIXME : support multiple servers
 400         sdks := []xaapiv1.SDK{}
 401         if err := g.httpCli.Get("/servers/0/sdks", &sdks); err != nil {
 402                 return int(syscallEBADE), err
 403         }
 404         msg += "\nList of installed cross SDKs (use: export XDS_SDK_ID=<< ID >>): \n"
 405         msg += "  ID\t\t\t\t\t | NAME\n"
 406         for _, s := range sdks {
 407                 msg += fmt.Sprintf("  %s\t | %s\n", s.ID, s.Name)
 408         }
 409
 410         if len(g.projects) > 0 && len(sdks) > 0 {
 411                 msg += fmt.Sprintf("\n")
 412                 msg += fmt.Sprintf("For example: \n")
 413                 msg += fmt.Sprintf("  XDS_PROJECT_ID=%q XDS_SDK_ID=%q  %s -x myGdbConf.ini\n",
 414                         g.projects[0].ID, sdks[0].ID, AppName)
 415         }
 416
 417         return 0, fmt.Errorf(msg)
 418 }