• Das Erstellen neuer Accounts wurde ausgesetzt. Bei berechtigtem Interesse bitte Kontaktaufnahme über die üblichen Wege. Beste Grüße der Admin

[FRAGE] request.session ist undefined

xorg1990

xorg1990

New member
Hi, gleich das nächste Problem.

Ich habe mit expessjs zwei routes definiert, einmal die Main route "/" und eine eine "stream" route

Code: 
const cockieSetting = {
		secret : "xxxTripleX",
		resave: false,
		saveUninitialized : false,
		cookie: {
			secure: true,
			maxAge: null,
		}
}

//app.use("/audio", express.static(__dirname + "/files"));

app.use(session(cockieSetting));

function getFilePath(fid,req , cb){
	if(fid == "123456srtwes");
	const path = __dirname+"/files/"+"DM_wtmw.wav";
	const pid = crypto.randomBytes(3).toString("hex");
	return cb(null, req, path, pid)
}




app.get("/stream/:pid" , function(req,res){
	let pid = req.params.pid;
	console.log(pid, req.session.uid)
	//if(pid === req.session.pid){
		const opts = {
				maxAge : 100,
				dotfiles: "deny",
					lastModified : false,
					cacheControl : false
		}
		res.sendFile(req.session.path, opts);
		console.log("file sended")
	//}
});

app.get("/:fid", function (req, res) {
	let fid = req.params.fid;
	req.session.uid = 2;
	getFilePath(fid, req, function(err, req, path, pid){
		res.setHeader('Access-Control-Allow-Origin', 'http://localhost');
		res.setHeader("Content-Type", "text/plain")
		req.session.pid = pid;
		req.session.path = path;
		res.send(pid);
		console.log("sended");
	});
});

In der main Route wird req.session.uid = 2;

gesetzt, served man dann aber die "/stream/:pid" route an ist req.session.uid undefiend. Warum?

req.session existiert aber nur das .uid fehlt.

- - - Aktualisiert - - -

Habe den Übeltäter gefunden, bei einen Request von einem HTML Media Element werden keine cookies bzw sessions ausgetauscht, die brauche ich aber zwingend.
und nu?

- - - Aktualisiert - - -

Das wirft mich nun wider komplette zurück, da ich nicht weiß wie ich die Adresse zu wav Datei Verstecken soll.

so hätte ich eine id gesetzt beim Aufruf der Seite. Die Source Adresse hätte so ausgesehen "http://192.168.2.108/stream/id"
wenn die id und die id im session übereinstimmen beginnt der Stream sonnst nicht.
 
Zuletzt bearbeitet:
Ok, wie erzeigt man den "Einmal url's"??

Und geht das überhaupt, angenommen ich habe eine Einmal URL und der User springt ans das Ende der Datei, dann wird ein request gefeuert der aber nicht mehr gültig ist, da die Adresse verfallen ist.

Und die session sind doch da, es ist nur versteckt.
Code: 
server listen at port 80
IncomingMessage {
 ***///viele Zeilen 
  _parsedOriginalUrl: 
   Url {
     protocol: null,
     slashes: null,
     auth: null,
     host: null,
     port: null,
     hostname: null,
     hash: null,
     search: '?_=1516793495426',
     query: '_=1516793495426',
     pathname: '/getFile/123456srtwes',
     path: '/getFile/123456srtwes?_=1516793495426',
     href: '/getFile/123456srtwes?_=1516793495426',
     _raw: '/getFile/123456srtwes?_=1516793495426' },
  sessionStore: 
   MemoryStore {
     domain: null,
     _events: 
      { disconnect: [Function: ondisconnect],
        connect: [Function: onconnect] },
     _eventsCount: 2,
     _maxListeners: undefined,
     sessions: {},
     generate: [Function] },
  sessionID: 'gWQpJTg7d9qESIWw44WVIvSblxj1Uw8m',
  session: 
   Session {
     cookie: 
      { path: '/',
        _expires: null,
        originalMaxAge: null,
        httpOnly: true,
        secure: false } },
  route: 
   Route {
     path: '/getFile/:fid',
     stack: [ [Object] ],
     methods: { get: true } } }
*****************************
IncomingMessage {
  _readableState: 
   ReadableState {
     objectMode: false,
     highWaterMark: 16384,
     buffer: BufferList { head: null, tail: null, length: 0 },
     length: 0,
     pipes: null,
     pipesCount: 0,
     flowing: null,
     ended: true,
     endEmitted: false,
     reading: false,
     sync: true,
     needReadable: false,
     emittedReadable: true,
     readableListening: false,
     resumeScheduled: false,
     defaultEncoding: 'utf8',
     ranOut: false,
     awaitDrain: 0,
     readingMore: true,
     decoder: null,
     encoding: null },
  readable: true,
  domain: null,
  _events: {},
  _eventsCount: 0,
  _maxListeners: undefined,
  socket: 
   Socket {
     connecting: false,
     _hadError: false,
     _handle: 
      TCP {
        bytesRead: 472,
        _externalStream: {},
        fd: 14,
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState: 
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [Object],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        defaultEncoding: 'utf8',
        ranOut: false,
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events: 
      { end: [Object],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Object],
        timeout: [Function],
        error: [Function: socketOnError],
        close: [Object],
        data: [Function: socketOnData],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState: 
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] },
     writable: true,
     allowHalfOpen: true,
     destroyed: false,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server: 
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 2,
        _handle: [Object],
        _usingSlaves: false,
        _slaves: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        _pendingResponseData: 0,
        _connectionKey: '6::::80' },
     _server: 
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 2,
        _handle: [Object],
        _usingSlaves: false,
        _slaves: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        _pendingResponseData: 0,
        _connectionKey: '6::::80' },
     _idleTimeout: 120000,
     _idleNext: 
      Socket {
        connecting: false,
        _hadError: false,
        _handle: [Object],
        _parent: null,
        _host: null,
        _readableState: [Object],
        readable: true,
        domain: null,
        _events: [Object],
        _eventsCount: 10,
        _maxListeners: undefined,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: true,
        destroyed: false,
        _bytesDispatched: 380,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: [Object],
        _server: [Object],
        _idleTimeout: 120000,
        _idleNext: [Object],
        _idlePrev: [Circular],
        _idleStart: 17391,
        parser: [Object],
        on: [Function: socketOnWrap],
        _paused: false,
        read: [Function],
        _consuming: true,
        _httpMessage: null },
     _idlePrev: 
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Object],
        _timer: [Object],
        _unrefed: true,
        msecs: 120000,
        nextTick: false },
     _idleStart: 17661,
     parser: 
      HTTPParser {
        '0': [Function: parserOnHeaders],
        '1': [Function: parserOnHeadersComplete],
        '2': [Function: parserOnBody],
        '3': [Function: parserOnMessageComplete],
        '4': [Function: onParserExecute],
        _headers: [],
        _url: '',
        _consumed: true,
        socket: [Circular],
        incoming: [Circular],
        outgoing: null,
        maxHeaderPairs: 2000,
        onIncoming: [Function: parserOnIncoming] },
     on: [Function: socketOnWrap],
     _paused: false,
     read: [Function],
     _consuming: true,
     _httpMessage: 
      ServerResponse {
        domain: null,
        _events: [Object],
        _eventsCount: 1,
        _maxListeners: undefined,
        output: [],
        outputEncodings: [],
        outputCallbacks: [],
        outputSize: 0,
        writable: true,
        _last: false,
        upgrading: false,
        chunkedEncoding: false,
        shouldKeepAlive: true,
        useChunkedEncodingByDefault: true,
        sendDate: true,
        _removedHeader: {},
        _contentLength: null,
        _hasBody: true,
        _trailer: '',
        finished: false,
        _headerSent: false,
        socket: [Circular],
        connection: [Circular],
        _header: null,
        _headers: [Object],
        _headerNames: [Object],
        _onPendingData: [Function: updateOutgoingData],
        req: [Circular],
        locals: {},
        writeHead: [Function: writeHead],
        end: [Function: end] } },
  connection: 
   Socket {
     connecting: false,
     _hadError: false,
     _handle: 
      TCP {
        bytesRead: 472,
        _externalStream: {},
        fd: 14,
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState: 
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [Object],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        defaultEncoding: 'utf8',
        ranOut: false,
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events: 
      { end: [Object],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Object],
        timeout: [Function],
        error: [Function: socketOnError],
        close: [Object],
        data: [Function: socketOnData],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState: 
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',
        length: 0,
        writing: false,
        corked: 0,
        sync: true,
        bufferProcessing: false,
        onwrite: [Function],
        writecb: null,
        writelen: 0,
        bufferedRequest: null,
        lastBufferedRequest: null,
        pendingcb: 0,
        prefinished: false,
        errorEmitted: false,
        bufferedRequestCount: 0,
        corkedRequestsFree: [Object] },
     writable: true,
     allowHalfOpen: true,
     destroyed: false,
     _bytesDispatched: 0,
     _sockname: null,
     _pendingData: null,
     _pendingEncoding: '',
     server: 
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 2,
        _handle: [Object],
        _usingSlaves: false,
        _slaves: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        _pendingResponseData: 0,
        _connectionKey: '6::::80' },
     _server: 
      Server {
        domain: null,
        _events: [Object],
        _eventsCount: 2,
        _maxListeners: undefined,
        _connections: 2,
        _handle: [Object],
        _usingSlaves: false,
        _slaves: [],
        _unref: false,
        allowHalfOpen: true,
        pauseOnConnect: false,
        httpAllowHalfOpen: false,
        timeout: 120000,
        _pendingResponseData: 0,
        _connectionKey: '6::::80' },
     _idleTimeout: 120000,
     _idleNext: 
      Socket {
        connecting: false,
        _hadError: false,
        _handle: [Object],
        _parent: null,
        _host: null,
        _readableState: [Object],
        readable: true,
        domain: null,
        _events: [Object],
        _eventsCount: 10,
        _maxListeners: undefined,
        _writableState: [Object],
        writable: true,
        allowHalfOpen: true,
        destroyed: false,
        _bytesDispatched: 380,
        _sockname: null,
        _pendingData: null,
        _pendingEncoding: '',
        server: [Object],
        _server: [Object],
        _idleTimeout: 120000,
        _idleNext: [Object],
        _idlePrev: [Circular],
        _idleStart: 17391,
        parser: [Object],
        on: [Function: socketOnWrap],
        _paused: false,
        read: [Function],
        _consuming: true,
        _httpMessage: null },
     _idlePrev: 
      TimersList {
        _idleNext: [Circular],
        _idlePrev: [Object],
        _timer: [Object],
        _unrefed: true,
        msecs: 120000,
        nextTick: false },
     _idleStart: 17661,
     parser: 
      HTTPParser {
        '0': [Function: parserOnHeaders],
        '1': [Function: parserOnHeadersComplete],
        '2': [Function: parserOnBody],
        '3': [Function: parserOnMessageComplete],
        '4': [Function: onParserExecute],
        _headers: [],
        _url: '',
        _consumed: true,
        socket: [Circular],
        incoming: [Circular],
        outgoing: null,
        maxHeaderPairs: 2000,
        onIncoming: [Function: parserOnIncoming] },
     on: [Function: socketOnWrap],
     _paused: false,
     read: [Function],
     _consuming: true,
     _httpMessage: 
      ServerResponse {
        domain: null,
        _events: [Object],
        _eventsCount: 1,
        _maxListeners: undefined,
        output: [],
        outputEncodings: [],
        outputCallbacks: [],
        outputSize: 0,
        writable: true,
        _last: false,
        upgrading: false,
        chunkedEncoding: false,
        shouldKeepAlive: true,
        useChunkedEncodingByDefault: true,
        sendDate: true,
        _removedHeader: {},
        _contentLength: null,
        _hasBody: true,
        _trailer: '',
        finished: false,
        _headerSent: false,
        socket: [Circular],
        connection: [Circular],
        _header: null,
        _headers: [Object],
        _headerNames: [Object],
        _onPendingData: [Function: updateOutgoingData],
        req: [Circular],
        locals: {},
        writeHead: [Function: writeHead],
        end: [Function: end] } },
  httpVersionMajor: 1,
  httpVersionMinor: 1,
  httpVersion: '1.1',
  complete: true,
  headers: 
   { host: '192.168.2.108',
     'user-agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:57.0) Gecko/20100101 Firefox/57.0',
     accept: 'audio/webm,audio/ogg,audio/wav,audio/*;q=0.9,application/ogg;q=0.7,video/*;q=0.6,*/*;q=0.5',
     'accept-language': 'de,en-US;q=0.7,en;q=0.3',
     referer: 'http://localhost/websocketTest.html',
     range: 'bytes=0-',
     cookie: 'stream=s%3ApDRe03bF8zgc2i4JJev-a7Ai-6TGcfnK.hX9PIP4LY%2BzrssY7vzOINf8qdV4%2BD74Jub0k3FBZpj8',
     connection: 'keep-alive' },
  rawHeaders: 
   [ 'Host',
     '192.168.2.108',
     'User-Agent',
     'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:57.0) Gecko/20100101 Firefox/57.0',
     'Accept',
     'audio/webm,audio/ogg,audio/wav,audio/*;q=0.9,application/ogg;q=0.7,video/*;q=0.6,*/*;q=0.5',
     'Accept-Language',
     'de,en-US;q=0.7,en;q=0.3',
     'Referer',
     'http://localhost/websocketTest.html',
     'Range',
     'bytes=0-',
     'Cookie',
     'stream=s%3ApDRe03bF8zgc2i4JJev-a7Ai-6TGcfnK.hX9PIP4LY%2BzrssY7vzOINf8qdV4%2BD74Jub0k3FBZpj8',
     'Connection',
     'keep-alive' ],
  trailers: {},
  rawTrailers: [],
  upgrade: false,
  url: '/stream/582b0e',
  method: 'GET',
  statusCode: null,
  statusMessage: null,
  client: 
   Socket {
     connecting: false,
     _hadError: false,
     _handle: 
      TCP {
        bytesRead: 472,
        _externalStream: {},
        fd: 14,
        reading: true,
        owner: [Circular],
        onread: [Function: onread],
        onconnection: null,
        writeQueueSize: 0,
        _consumed: true },
     _parent: null,
     _host: null,
     _readableState: 
      ReadableState {
        objectMode: false,
        highWaterMark: 16384,
        buffer: [Object],
        length: 0,
        pipes: null,
        pipesCount: 0,
        flowing: true,
        ended: false,
        endEmitted: false,
        reading: true,
        sync: false,
        needReadable: true,
        emittedReadable: false,
        readableListening: false,
        resumeScheduled: false,
        defaultEncoding: 'utf8',
        ranOut: false,
        awaitDrain: 0,
        readingMore: false,
        decoder: null,
        encoding: null },
     readable: true,
     domain: null,
     _events: 
      { end: [Object],
        finish: [Function: onSocketFinish],
        _socketEnd: [Function: onSocketEnd],
        drain: [Object],
        timeout: [Function],
        error: [Function: socketOnError],
        close: [Object],
        data: [Function: socketOnData],
        resume: [Function: onSocketResume],
        pause: [Function: onSocketPause] },
     _eventsCount: 10,
     _maxListeners: undefined,
     _writableState: 
      WritableState {
        objectMode: false,
        highWaterMark: 16384,
        needDrain: false,
        ending: false,
        ended: false,
        finished: false,
        decodeStrings: false,
        defaultEncoding: 'utf8',

   Url {
     protocol: null,
     slashes: null,
     auth: null,
     host: null,
     port: null,
     hostname: null,
     hash: null,
     search: null,
     query: null,
     pathname: '/stream/582b0e',
     path: '/stream/582b0e',
     href: '/stream/582b0e',
     _raw: '/stream/582b0e' },
  sessionStore: 
   MemoryStore {
     domain: null,
     _events: 
      { disconnect: [Function: ondisconnect],
        connect: [Function: onconnect] },
     _eventsCount: 2,
     _maxListeners: undefined,
     sessions: { gWQpJTg7d9qESIWw44WVIvSblxj1Uw8m: '{"cookie":{"originalMaxAge":null,"expires":null,"secure":false,"httpOnly":true,"path":"/"},"userID":"582b0e"}' },
     generate: [Function] },
  sessionID: 'Mf3i-qzHin-tFesF8sb54TXVzJFSPIai',
  session: 
   Session {
     cookie: 
      { path: '/',
        _expires: null,
        originalMaxAge: null,
        httpOnly: true,
        secure: false } },
  route: 
   Route {
     path: '/stream/:pid',
     stack: [ [Object] ],
     methods: { get: true } } }

582b0e undefined
alles was oberhalb von der ************* Riehe steht ist vom ajax request und alles darunter vom src request.

im Ajax request wird eien session erstellt mit der sessionID: 'gWQpJTg7d9qESIWw44WVIvSblxj1Uw8m',

Die findet man auch im src request wider nur eben versteckt:
und da ist auch meine UserID
 
"Einmal" muss ja nicht unbedingt genau einmal bedeuten, sondern kann ja auch 5 Minuten oder "nur von ein bestimmten IP" bedeuten. Da kannst du so creativ werden, wie du willst.

Erzeugen musst du die gar nicht. Du musst nur eine dynamische Route bauen. Im Grunde würde es auch reichen, wenn du etwas in den Query-Teil der URL schreibst, anhand dessen du dann entscheidest, ob du die Datei auslieferst oder nicht.
 
OK, danke dir.
Habe mir mittlerweile etwas zusammen gebastelt. Das mit der Lebensdauer für die URl funktioniert nicht ganz so gut, da man auch zurück spulen kann.
Mit Mehraufwand könnte man die Zeit zum "cookie expires" hinzurechne die der user zurück gespult hat aber nee, eine 100% Absicherung gibt es nicht.

Paar fakten habe ich noch: ich streame über fs.createReadStream gepiped nach responce.
Chrome sende in einem 4:50min langen audio 4 requests. Wären FF gar kein request mehr sendet.

Nehme ich aber die expressjs sendFile Methode, dann sende beide Browser 4 request's.
"Seek't" Man im Audio wird immer ein Request gesendet.
 
Du musst dich einloggen oder registrieren, um hier zu antworten.
Zurück
Oben