// GetInfo unmarshals the optional metadata associated with the file
// into the result parameter. For example:
//
// result := struct{ INode int }{}
// err = file.GetInfo(&result)
// if err != nil {
// panic(err.String())
// }
// fmt.Printf("inode: %d\n", result.INode)
//
func (file *GridFile) GetInfo(result interface{}) (err os.Error) {
file.m.Lock()
if file.doc.Metadata != nil {
err = bson.Unmarshal(file.doc.Metadata.Data, result)
}
file.m.Unlock()
return
}
func (socket *mongoSocket) resetNonce() {
debugf("Socket %p to %s: requesting a new nonce", socket, socket.addr)
op := &queryOp{}
op.query = &getNonceCmd{GetNonce: 1}
op.collection = "admin.$cmd"
op.limit = -1
op.replyFunc = func(err os.Error, reply *replyOp, docNum int, docData []byte) {
if err != nil {
socket.kill(os.NewError("getNonce: " + err.String()))
return
}
result := &getNonceResult{}
err = bson.Unmarshal(docData, &result)
if err != nil {
socket.kill(os.NewError("Failed to unmarshal nonce: " + err.String()))
return
}
debugf("Socket %p to %s: nonce unmarshalled: %#v", socket, socket.addr, result)
if result.Code == 13390 {
// mongos doesn't yet support auth (see http://j.mp/mongos-auth)
result.Nonce = "mongos"
} else if result.Nonce == "" {
var msg string
if result.Err != "" {
msg = fmt.Sprintf("Got an empty nonce: %s (%d)", result.Err, result.Code)
} else {
msg = "Got an empty nonce"
}
socket.kill(os.NewError(msg))
return
}
socket.Lock()
if socket.cachedNonce != "" {
socket.Unlock()
panic("resetNonce: nonce already cached")
}
socket.cachedNonce = result.Nonce
socket.gotNonce.Signal()
socket.Unlock()
}
err := socket.Query(op)
if err != nil {
socket.kill(os.NewError("resetNonce: " + err.String()))
}
}
// Estimated minimum cost per socket: 1 goroutine + memory for the largest
// document ever seen.
func (socket *mongoSocket) readLoop() {
p := [36]byte{}[:] // 16 from header + 20 from OP_REPLY fixed fields
s := [4]byte{}[:]
conn := socket.conn // No locking, conn never changes.
for {
// XXX Handle timeouts, , etc
err := fill(conn, p)
if err != nil {
socket.kill(err)
return
}
totalLen := getInt32(p, 0)
responseTo := getInt32(p, 8)
opCode := getInt32(p, 12)
// Don't use socket.server.Addr here. socket is not locked.
debugf("Socket %p to %s: got reply (%d bytes)", socket, socket.addr, totalLen)
_ = totalLen
if opCode != 1 {
socket.kill(os.NewError("opcode != 1, corrupted data?"))
return
}
reply := replyOp{
flags: uint32(getInt32(p, 16)),
cursorId: getInt64(p, 20),
firstDoc: getInt32(p, 28),
replyDocs: getInt32(p, 32),
}
stats.receivedOps(+1)
stats.receivedDocs(int(reply.replyDocs))
socket.Lock()
replyFunc, replyFuncFound := socket.replyFuncs[uint32(responseTo)]
socket.Unlock()
if replyFunc != nil && reply.replyDocs == 0 {
replyFunc(nil, &reply, -1, nil)
} else {
for i := 0; i != int(reply.replyDocs); i++ {
err := fill(conn, s)
if err != nil {
socket.kill(err)
return
}
b := make([]byte, int(getInt32(s, 0)))
// copy(b, s) in an efficient way.
b[0] = s[0]
b[1] = s[1]
b[2] = s[2]
b[3] = s[3]
err = fill(conn, b[4:])
if err != nil {
socket.kill(err)
return
}
if globalDebug && globalLogger != nil {
m := bson.M{}
if err := bson.Unmarshal(b, m); err == nil {
debugf("Socket %p to %s: received document: %#v", socket, socket.addr, m)
}
}
if replyFunc != nil {
replyFunc(nil, &reply, i, b)
}
// XXX Do bound checking against totalLen.
}
}
// Only remove replyFunc after iteration, so that kill() will see it.
socket.Lock()
if replyFuncFound {
socket.replyFuncs[uint32(responseTo)] = replyFunc, false
}
socket.Unlock()
// XXX Do bound checking against totalLen.
}
}
func (socket *mongoSocket) Login(db string, user string, pass string) os.Error {
socket.Lock()
for _, a := range socket.auth {
if a.db == db && a.user == user && a.pass == pass {
debugf("Socket %p to %s: login: db=%q user=%q (already logged in)", socket, socket.addr, db, user)
socket.Unlock()
return nil
}
}
if auth, found := socket.dropLogout(db, user, pass); found {
debugf("Socket %p to %s: login: db=%q user=%q (cached)", socket, socket.addr, db, user)
socket.auth = append(socket.auth, auth)
socket.Unlock()
return nil
}
socket.Unlock()
debugf("Socket %p to %s: login: db=%q user=%q", socket, socket.addr, db, user)
// Note that this only works properly because this function is
// synchronous, which means the nonce won't get reset while we're
// using it and any other login requests will block waiting for a
// new nonce provided in the defer call below.
nonce, err := socket.getNonce()
if err != nil {
return err
}
defer socket.resetNonce()
psum := md5.New()
psum.Write([]byte(user + ":mongo:" + pass))
ksum := md5.New()
ksum.Write([]byte(nonce + user))
ksum.Write([]byte(hex.EncodeToString(psum.Sum())))
key := hex.EncodeToString(ksum.Sum())
cmd := authCmd{Authenticate: 1, User: user, Nonce: nonce, Key: key}
var mutex sync.Mutex
var replyErr os.Error
mutex.Lock()
op := queryOp{}
op.query = &cmd
op.collection = db + ".$cmd"
op.limit = -1
op.replyFunc = func(err os.Error, reply *replyOp, docNum int, docData []byte) {
defer mutex.Unlock()
if err != nil {
replyErr = err
return
}
// Must handle this within the read loop for the socket, so
// that concurrent login requests are properly ordered.
result := &authResult{}
err = bson.Unmarshal(docData, result)
if err != nil {
replyErr = err
return
}
if !result.Ok {
replyErr = os.NewError(result.ErrMsg)
}
socket.Lock()
socket.dropAuth(db)
socket.auth = append(socket.auth, authInfo{db, user, pass})
socket.Unlock()
}
err = socket.Query(&op)
if err != nil {
return err
}
mutex.Lock() // Wait.
if replyErr != nil {
debugf("Socket %p to %s: login error: %s", socket, socket.addr, replyErr)
} else {
debugf("Socket %p to %s: login successful", socket, socket.addr)
}
return replyErr
}
